Walkthrough: Criar um tipo de campo personalizado

Artigo
11/27/2008

Este tópico fornece uma guia passo a passo para criar um personalizado tipo de campo em the most comum situação: o processamento do campo em um exibição de lista e em modo de exibição é tratado por um RenderPattern no campo definição arquivo, enquanto processamento campo nos modos novo e editar é tratado por um modelo processamento único que funciona together with o CreateChildControls método M:Microsoft.SharePoint.WebControls.BaseFieldControl.CreateChildControls. Você criará um campo que destina-se a armazenar 10-dígito International Standard Book Number (ISBN).

Pré-requisitos

Esta explicação passo a passo requer que você tenha a seguinte aplicativos instalados em um computador que esteja execução a sistema operacional Windows Server 2003:

Windows SharePoint Services 3.0
Visual Studio 2005 Microsoft
Extensões Microsoft Visual Studio 2005 para Windows SharePoint Services 3.0, versão 1.0 ou posterior

Para se preparar para desenvolvimento de personalizado tipos campo

Em Visual Studio, selecione ferramentas externas o menu Ferramentas .
O External Tools diálogo, clique em Adicionar e digite obter chave pública conjunto de módulos (assembly) a título .
Preencha o caixa de texto comando navegando para Sn.exe. É geralmente instalado no seguinte localidade: C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\sn.exe.
Em caixa de texto o argumentos, o seguinte tipo (com diferenciação de maiúsculas e minúsculas) -TP "$ (TargetPath)" .
Ative a caixa de seleção Use Output janela.
Clique em OK . O comando novo é adicionado para o menu Ferramentas .

Configurando o projeto

Para configurar o personalizado campo projeto

Em Visual Studio 2005, selecione Novo Projeto o menu do arquivo.
Sobre o diálogo New Project, selecione SharePoint na janela Project Types. (Se não houver nenhuma opção projeto SharePoint na janela, você precisará instalar Visual Studio 2005 Extensions para Windows SharePoint Services 3.0, versão 1.0 ou posterior.)
Selecione vazio na janela modelos.
Na caixa nome, tipo ISBN_Field_Type .
Clique em OK .
Em Gerenciador de Soluções , clique com o botão direito do mouse Nome do projeto, ISBN_Field_Type e selecione propriedades , em seguida, na guia Construir Eventos.

Digite a seguinte a caixa evento Post-Build linha de comando. Essas linhas irão garantir que cada tempo você reconstruir o projeto, a versão mais recente dos arquivos no seu projeto são copiados para a localidade correta e Windows SharePoint Services 3.0 for reiniciado para que ele irá carregar a versão mais recente do assembly.
```
                          cd "$(ProjectDir)"
"%programfiles%\microsoft visual studio 8\sdk\v2.0\bin\gacutil" /i "$(TargetPath)" /nologo /f
%systemroot%\system32\iisapp.vbs /a "SharePoint_App_Pool" /r
xcopy *.ascx "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\CONTROLTEMPLATES\" /y
xcopy fldtypes*.xml "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\XML\" /y
```
Substituir o real SharePoint_App_Pool Nome do pool de aplicativos de Internet Information Server (IIS) que é atribuído a seu Windows SharePoint Services 3.0 aplicativo da Web. Isso geralmente é o mesmo nome como o site da Web IIS que contém o aplicativo; de exemplo, "SharePoint - 80". (As aspas poderá ser omitidas se não houver espaços no nome.)
Clique em qualquer outro habilitado controle na guia de modo que Visual Studio detecta suas alterações e um asterisco aparece em rotular o guia, em seguida, selecione salvar todos os a partir de menu do arquivo.
In Solution Explorer, right-click the project name, ISBN_Field_Type, and select Add, then New Item.
Sobre o diálogo Add New Item, selecione SharePoint na janela Categorias e, em seguida, de controle de campo na janela modelos.
Na caixa nome, tipo ISBN Adicionar clique e . Isso cria dois arquivos que você irá editar em uma etapa posterior: ISBN.Field.cs e ISBN.FieldControl.cs. Um nome forte também é criada e armazenada em um arquivo chamado Temporary.snk no seu projeto.
Em Gerenciador de Soluções , clique com o botão direito do mouse o projeto Nome, selecione propriedades e ISBN_Field_Type .
Abra o Aplicativo guia e alteração Conjunto de Módulos (Assembly) Nome a mycompany . SharePoint . ISBN_Field_Type . (Em todo este explicação passo a passo, substituir mycompany com o nome da sua empresa.)
Altere para mycompany padrão namespace . SharePoint .
Clique no salvar todos os botão sobre a barra de ferramentas.
Em Gerenciador de Soluções , clique com o botão direito do mouse o nó Referências e selecione Adicionar Referência .
Sobre o diálogo Add Reference, aberto o guia procurar e navegar para C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\.
Selecione PresentationFramework.dll OK . (Este assembly contém a definição do ValidationRule T:System.Windows.Controls.ValidationRule classe que está relacionado no arquivo que você criar no próximo procedimento.)

Criando a classe da regra de validação

Para criar uma classe regra validação

In Solution Explorer, right-click the project name, ISBN_Field_Type, and select Add, then Class.
Selecione Visual C# projeto itens na janela Categorias e, em seguida, classe na janela modelos.
Na caixa nome, tipo ISBN10ValidationRule.cs e clique adicionar .

No ISBN10ValidationRule.cs arquivo que é criado, adicionar essas using instruções using:

                          using System.Text.RegularExpressions;
using System.Windows.Controls;
using System.Globalization;

Alterar o espaço para nome de acordo com as diretrizes em Namespace Naming Guidelines. Neste explicação passo a passo, use mycompany . System.Windows.Controls .

Substituir o declaração de classe o seguinte codificar:

                          public class ISBN10ValidationRule : ValidationRule
{
    private const Int32 ISBNMODULO = 11;

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        String iSBN = (String)value;
        String errorMessage = "";

        Regex rxISBN = new Regex(@"^(?'GroupID'\d{1,5})-(?'PubPrefix'\d{1,7})-(?'TitleID'\d{1,6})-(?'CheckDigit'[0-9X]{1})$");

        if (!rxISBN.IsMatch(iSBN))
        {
            errorMessage = "An ISBN must have this structure:\n1-5 digit Group ID, hyphen, \n1-7 digit Publisher Prefix, hyphen, \n1-6 digit Title ID, hyphen, \n1 Check Digit (which can be \"X\" to indicate \"10\").\n";
        }

        if (errorMessage == "") // Matched the RegEx, so check for group length errors.
        {
            Match mISBN = rxISBN.Match(iSBN);
            GroupCollection groupsInString = mISBN.Groups;

            String groupID = groupsInString["GroupID"].Value;
            String pubPrefix = groupsInString["PubPrefix"].Value;

            if ((groupID.Length + pubPrefix.Length) >= 9)
            {
                errorMessage = "The Group ID and Publisher Prefix can total no more than 8 digits.\n";
            }

            String titleID = groupsInString["TitleID"].Value;

            if (((groupID.Length + pubPrefix.Length) + titleID.Length) != 9)
            {
                errorMessage = errorMessage + "The Group ID, Publisher Prefix, and \nTitle ID must total exactly 9 digits.\n";
            }

            if (errorMessage == "") //No group length errors, so verify the check digit algorithm.
            {
                Int32 checkDigitValue;
                String checkDigit = groupsInString["CheckDigit"].Value;

                // To ensure check digit is one digit, "10" is represented by "X".
                if (checkDigit == "X")
                {
                    checkDigitValue = 10;
                }
                else
                {
                    checkDigitValue = Convert.ToInt32(checkDigit);
                }

                String iSBN1st3Groups = groupID + pubPrefix + titleID; //Concatenate without the hyphens.

                // Sum the weighted digits.
                Int32 weightedSum = (10 * Convert.ToInt32(iSBN1st3Groups.Substring(0, 1))) +
                                     (9 * Convert.ToInt32(iSBN1st3Groups.Substring(1, 1))) +
                                     (8 * Convert.ToInt32(iSBN1st3Groups.Substring(2, 1))) +
                                     (7 * Convert.ToInt32(iSBN1st3Groups.Substring(3, 1))) +
                                     (6 * Convert.ToInt32(iSBN1st3Groups.Substring(4, 1))) +
                                     (5 * Convert.ToInt32(iSBN1st3Groups.Substring(5, 1))) +
                                     (4 * Convert.ToInt32(iSBN1st3Groups.Substring(6, 1))) +
                                     (3 * Convert.ToInt32(iSBN1st3Groups.Substring(7, 1))) +
                                     (2 * Convert.ToInt32(iSBN1st3Groups.Substring(8, 1))) +
                                      checkDigitValue;

                Int32 remainder = weightedSum % ISBNMODULO;  // ISBN is invalid if weighted sum modulo 11 is not 0.

                if (remainder != 0)
                {
                    errorMessage = "Number fails Check Digit verification.";
                }

                if (errorMessage == "") // Passed check digit verification. 
                {
                    return new ValidationResult(true, "This is a valid ISBN.");
                }// end check digit verification passed

                else // the check digit verification failed
                {
                    return new ValidationResult(false, errorMessage);
                }

            }// end no group length errors

            else // There was some error in a group length
            {
                return new ValidationResult(false, errorMessage);
            }

        }// end RegEx match succeeded

        else // There was a RegEx match failure
        {
              return new ValidationResult(false, errorMessage);
        }

    }// end Validate method 

}// end ISBN10ValidationRule class

A classe regra validação que você acabou de criar contém toda a lógica detalhada validação. Para obter mais informações sobre classes regra validação, consulte System.Text.RegularExpressions e ValidationRule.

Criando a classe do campo personalizado

Para criar um personalizado campo classe

Abra o arquivo ISBN.Field.cs ISBN.Field.cs. Um GUID, dois exigido Construtores e um substituir do FieldRenderingControl P:Microsoft.SharePoint.SPFieldText.FieldRenderingControl propriedade foram fornecidos. Apenas raramente você precisará modificar esses controles. Por padrão, sua nova classe campo está declarada como herdam SPFieldText. For the Purpose of este explicação passo a passo, essa é a escolha correta. (Para obter mais informações sobre as outras classes do qual você pode derivar seu personalizado tipo de campo, consulte Classes do campo personalizado.)

Adicione o seguinte usingISBN.Field.cs. Não se esqueça alteração "myCompany" com o nome da sua empresa:

                          using System.Windows.Controls;
using System.Globalization;
using MyCompany.SharePoint.WebControls;
using MyCompany.System.Windows.Controls;

Altere o espaço para nome para mycompany . SharePoint .
Adicione o seguinte substituir do GetValidatedString M:Microsoft.SharePoint.SPField.GetValidatedString(System.Object) método para a classe ISBNField:
```
                          public override string GetValidatedString(object value)
{
    if ((this.Required == true)
       &&
       ((value == null)
        ||
       ((String)value == "")))
    {
        throw new SPFieldValidationException(this.Title 
            + " must have a value.");
    }
    else
    {
        ISBN10ValidationRule rule = new ISBN10ValidationRule();
        ValidationResult result = rule.Validate(value, CultureInfo.InvariantCulture);

        if (!result.IsValid)
        {
            throw new SPFieldValidationException((String)result.ErrorContent);
        }
        else
        {
            return base.GetValidatedString(value);
        }
    }
}// end GetValidatedString
```
Este substituir ilustra um comum padrão para substituições de GetValidatedString:
- Substitui do GetValidatedString M:Microsoft.SharePoint.SPField.GetValidatedString(System.Object) método verificar se o campo é exigido e, se for, o método substituído gera um SPFieldValidationException T:Microsoft.SharePoint.SPFieldValidationException exceção quando o valor é NULL null ou um vazio String. Essa exceção é detectada pelo novo item e Editar Item páginas se o usuário tenta salvar o item da lista que está sendo criado ou editado. Este maiúsculas e minúsculas, a página permanece aberto e o Message propriedade da exceção causa uma mensagem de erro seja exibido sob o vazio P:Microsoft.SharePoint.SPFieldValidationException.Message campo.
- Substituições de lançar GetValidatedString M:Microsoft.SharePoint.SPField.GetValidatedString(System.Object) um SPFieldValidationException quando o valor não for válido, causando uma mensagem de erro seja exibido sob o inválido campo.
- Overrides of GetValidatedString then call the base GetValidatedString, if the value passes the custom validation.
Salvar e fechar o arquivo.

Criando o controle de processamento de campos

Para criar o controle processamento campo

Abrir ISBN.FieldControl.cs. Um GUID foi fornecido para o controle. Por padrão, sua nova classe campo está declarada como herdam TextField. For the Purpose of este explicação passo a passo, essa é a escolha correta. (Para obter mais informações sobre outras classes que personalizado controles campo podem ser derivado de Consulte Campo de Processamento Controles.)

Adicione a seguinte declaração usando:

                          using System.Web.UI.WebControls;

Altere o espaço para nome para mycompany . SharePoint.WebControls .
Adicione um campo protegido para uma ASP.NET Label T:System.Web.UI.Label W3 (World Wide Web) controle que será prefixo "ISBN" Antes cada número ISBN quando ele processa no modo Novo ou Editar. Não é necessário para adicionar um campo TextBox T:System.Web.UI.TextBox para manter o ISBN número próprio porque o personalizado ISBNFieldControl está herdando desse campo de TextField.
```
                          protected Label ISBNPrefix;
```
Adicionar próximo a seguinte substituir do DefaultTemplateName P:Microsoft.SharePoint.WebControls.TextField.DefaultTemplateName propriedade. O String que você está atribuição para esta propriedade é a identificação de um objeto RenderingTemplate T:Microsoft.SharePoint.WebControls.RenderingTemplate em um arquivo .ascx que você criar em uma etapa posterior e, em seguida, implantar para a pasta C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\CONTROLTEMPLATES. Since, in this example, we are not overriding ControlTemplate, Template, or TemplateName, the RenderingTemplate will be called like this: ControlTemplate will return Template, which will, in turn, return the Template property of whatever RenderingTemplate is named by TemplateName. Finalmente, o acessador get get de TemplateName retornará DefaultTemplateName. Em uma maiúsculas e minúsculas mais complexas onde, de exemplo, você tem separar modelos para os modos de novo e Editar, você precisará substituir uma ou mais da acima propriedades como bem como provavelmente o AlternateTemplateName ou propriedades DefaultAlternateTemplateName P:Microsoft.SharePoint.WebControls.TemplateBasedControl.DefaultAlternateTemplateName.
```
                          protected override string DefaultTemplateName
{
    get
    {
        return "ISBNFieldControl";
    }
}
```
Adicione o seguinte substituir do CreateChildControls método M:Microsoft.SharePoint.WebControls.TextField.CreateChildControls. O substituir não executar qualquer função se o subjacente é NULL ISBNField ISBNField null. (It might be null if the ISBNFieldControl is created independently of the setter for the ISBNField's FieldRenderingControl property — see the override of FieldRenderingControl in ISBN.Field.cs.). O método também não executar qualquer função se o SPControlMode é exibir. Isso ocorre porque processamento modo de exibição do campo for ser tratado, ele normalmente como, por um meio de um elemento d1b292bf-6be1-4372-b529-2c87d1f83d7d RenderPattern que esteja definido em um campo definição que você criar posteriormente neste explicação passo a passo. (In other situations, Display mode rendering is accomplished by a special template identified by the DisplayTemplateName property. Ele é raro que CreateChildControls faz tudo no modo de exibição para um personalizado tipo de campo. (Para obter mais informações sobre as diferentes maneiras de processamento personalizado campos, consulte Padrões de processamento do campo personalizado.)
```
                          protected override void CreateChildControls()
{
    if (this.Field != null && this.ControlMode != SPControlMode.Display)
    {

    }// end if there is a non-null underlying ISBNField and control mode is not Display

  //Do nothing if the ISBNField is null or control mode is Display.
}
```
Adicione o seguinte chamar para o método base como a primeira linha do condicional. Tal um chamar é geralmente necessária para garantir que o filho herdado controles são criados no maiúsculas e minúsculas que eles são processados totalmente ou parcialmente pelo de base CreateChildControls instead of por um modelo. For example, the "TextField" template in DefaultTemplates.ascx (in C:\program files\common files\microsoft shared\web server extensions\12\template\controltemplates) renders the child TextBox, but the CreateChildControls method adjusts the maximum size of the TextBox to match the maximum size of the underlying SPFieldText field. O de base CreateChildControls também pode criar dinâmico controles BaseValidator T:System.Web.UI.WebControls.BaseValidator. Normalmente, no entanto, não é necessário acessar para codificar a origem do método base, de modo que experimentos é necessário para determinar se ele precisa ser chamado e, em caso afirmativo, onde ele deve ser chamado no seu substituir.
```
                          // Make sure inherited child controls are completely rendered.
base.CreateChildControls();
```
Adicione as seguinte linhas para associar os controles filho no modelo de processamento com os campos controle filho declarados na sua personalizado controle campo (ou herdadas por seu pai). Você deve fazer isso agora embora o modelo processamento é algo que você não irá criar até uma etapa posterior, porque a chamar para o de base CreateChildControls será associar o filho herdado controles para o modelo processamento usado pelo pai do seu personalizado classe campo, não para o personalizado modelo processamento, para que a associação de base tem que ser substituído por um novo.
```
                          // Associate child controls in the .ascx file with the 
// fields allocated by this control.
this.ISBNPrefix = (Label)TemplateContainer.FindControl("ISBNPrefix");
this.textBox = (TextBox)TemplateContainer.FindControl("TextField");
```
Adicione a seguinte estrutura abaixo a codificar associação controle. Seu codificar deve fazer nada em um postback porque reinicializando em um postback seria cancelar as alterações em um usuário tem feitas com os valores dos controles filho.
```
                              if (!this.Page.IsPostBack)
    {

    }// end if this is not a postback 

//Do not reinitialize on a postback.
```

Dentro de estrutura condicional você adicionou na etapa a última, adicionar o seguinte condicional interna para inicializar o controle filho TextBox TextBox com um valor ISBN usar como padrão quando o modo controle é novo.

                          if (this.ControlMode == SPControlMode.New)
{
    textBox.Text = "0-000-00000-0";

} // end assign default value in New mode

Nada precisa ser feito no modo Editar, pois o OnLoaD M:Microsoft.SharePoint.WebControls.BaseFieldControl.OnLoaD(System.EventArgs) método irá inicializar ISBNFieldControl.Value para o valor de ItemFieldValue que mantém o atual valor do campo no de conteúdo banco de dados. Nesta apontar, seu substituir de CreateChildControls deve aspecto como o seguinte.

                          protected override void CreateChildControls()
{
    if (this.Field != null && this.ControlMode != SPControlMode.Display)
    {
        // Make sure inherited child controls are completely rendered.
        base.CreateChildControls();

        // Associate child controls in the .ascx file with the 
        // fields allocated by this control.
        this.ISBNPrefix = (Label)TemplateContainer.FindControl("ISBNPrefix");
        this.textBox = (TextBox)TemplateContainer.FindControl("TextField");

        if (!this.Page.IsPostBack)
        {
            if (this.ControlMode == SPControlMode.New)
            {
                textBox.Text = "0-000-00000-0";

            } // end assign default value in New mode

        }// end if this is not a postback 

     //Do not reinitialize on a postback.

    }// end if there is a non-null underlying ISBNField and control mode is not Display

 // Do nothing if the ISBNField is null or control mode is Display.
}

Adicione o seguinte substituir do Value propriedade P:Microsoft.SharePoint.WebControls.TextField.Value, qual é a propriedade do campo No interface do usuário . Se o usuário final tenha alterado o valor e ainda não foi salvo, então o Value P:Microsoft.SharePoint.WebControls.TextField.Value propriedade não é necessariamente o real valor da subjacente objeto ISBNField (derivado de SPFieldText) ISBNField ou o valor do campo no de conteúdo banco de dados. Observe que o acessador get get e set conjunto acessador começam chamado EnsureChildControls (que irão chamar CreateChildControls quando necessário). Chamada EnsureChildControls é obrigatória, a menos que (1) você chamar a propriedade de base primeira e (2) você sabe que definir set e get assessores chamar EnsureChildControls. Se você foram substituindo o subjacente TextBox T:System.Web.UI.TextBox controle filho herdadas TextField com um tipo de controle, uma caixa drop-down list, such as totalmente diferente, em seguida, definir o set acessador e acessador get get seria precisará definir esse controle diretamente em vez de chamar a propriedade de base. Para garantir que o controle inicialmente carrega com o valor no subjacente ISBNField ISBNField objeto, a OnLoad M:Microsoft.SharePoint.WebControls.BaseFieldControl.OnLoad método definirá ISBNFieldControl.Value para o valor de ItemFieldValue que é o valor da subjacente objeto ISBNField ISBNField.
```
                          public override object Value
{
    get
    {
        EnsureChildControls();
        return base.Value;
    }
    set
    {
         EnsureChildControls();
         base.Value = (String)value;
         // The value of the ISBNPrefix field is hardcoded in the
         // template, so it is not set here.
    }
}
```

Criando o modelo de processamento de campos

Para criar o modelo processamento

In Solution Explorer, right-click the project name, ISBN_Field_Type, and select Add, then New Item.
Selecione Visual C# projeto itens na janela Categorias e, em seguida, arquivo de texto na janela modelos.
Na caixa nome, tipo ISBNFieldControl.ascx e clique adicionar . Fazer Não pôr o arquivo em uma subpasta da pasta projeto ou os comandos que você criou anteriormente neste explicação passo a passo Post-Build não irá localizá-la.)
No arquivo ISBNFieldControl.ascx ISBNFieldControl.ascx que é criado, adicionar o seguinte texto marcação:
```
                          <%@ Control Language="C#" %>
<%@ Assembly name="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="SharePoint" Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" Namespace="Microsoft.SharePoint.WebControls" %>

<SharePoint:RenderingTemplate ID="ISBNFieldControl" runat="server">
  <Template>
    <asp:Label ID="ISBNPrefix" Text="ISBN" runat="server" />
    &nbsp;
    <asp:TextBox ID="TextField" runat="server"  />
  </Template>
</SharePoint:RenderingTemplate>
```
Observe o seguinte fatos sobre este marcação:
- O ID do RenderingTemplate deve ser idêntico de seqüência de caracteres que você usou em sua substituir do DefaultTemplateName T:Microsoft.SharePoint.WebControls.TextField.DefaultTemplateName propriedade.
- O atributo Text texto do Label controle rótulo é definido aqui no modelo porque ele nunca é alterada.
- An HTML " " element comes between the two controls.
- O TextBox TextBox definição é idêntico ao que no "TextField" RenderingTemplateC:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\CONTROLTEMPLATES\DefaultTemplates.ascx definidos. Mas a definição deve ser repetida aqui porque seu substituir de DefaultTemplateName aponta para este personalizado modelo não o modelo "TextField". O mesmo ID é usado no personalizado modelo porque o de base CreateChildControls CreateChildControls método (veja acima) podem referir para o controle por este ID.
Salve o arquivo e depois feche-o.

Criando a definição Tipo de campo

Para criar o campo definição de tipo

Em Visual Studio, compilar o projeto. O projeto não é concluído, mas você precisa compilar nesse tempo para gerar um GUID e um Public Key Token para o assembly.
In Solution Explorer, right-click the project name, ISBN_Field_Type, and select Add, then New Item.
Selecione Visual C# projeto itens na janela Categorias e, em seguida, XML arquivo na janela modelos.
Na caixa nome, tipo fldtypes_ISBNField.xml e clique adicionar . (The file name Deve começa com "fldtypes". Além disso, ele deve Não Ser pôr em uma subpasta da pasta projeto ou os comandos Post-Build você criou anteriormente neste será explicação passo a passo não localizá-la.)

No arquivo fldtypes_ISBNField.xml fldtypes_ISBNField.xml que é criado, adicionar o seguinte texto marcação:

                          <?xml version="1.0" encoding="utf-8" ?>
<FieldTypes>
  <FieldType>
    <Field name="TypeName">ISBN</Field>
    <Field name="ParentType">Text</Field>
    <Field name="TypeDisplayName">ISBN</Field>
    <Field name="TypeShortDescription">ISBN for a book</Field>
    <Field name="UserCreatable">TRUE</Field>
    <Field name="ShowOnListCreate">TRUE</Field>
    <Field name="ShowOnSurveyCreate">TRUE</Field>
    <Field name="ShowOnDocumentLibraryCreate">TRUE</Field>
    <Field name="ShowOnColumnTemplateCreate">TRUE</Field>
    <Field name="FieldTypeClass">MyCompany.SharePoint.ISBNField, MyCompany.SharePoint.ISBN_Field_Type, Version=1.0.0.0, Culture=neutral, PublicKeyToken=token</Field>

  </FieldType>
</FieldTypes>

Este arquivo Define o personalizado tipo de campo para Windows SharePoint Services 3.0. Para obter detalhes sobre a finalidade e o significado dos seus elementos, consulte Definição Tipo de campo personalizado, Elemento FieldTypes (tipos de campos)Elemento FieldType (tipos de campos) e Elemento de campo (tipos de campos). Note that the <Field name="FieldTypeClass"> element must be entirely on one line.

In the <Field name="FieldTypeClass"> element, replace MyCompany in both the fully qualified class name and the assembly name with the name of your company; and replace token with the Public Key Token for your assembly. Para obter a Public Key token, selecione obter chave pública conjunto de módulos (assembly) o menu Ferramentas . O Public Key token será exibido na janela de saída.
Agora, adicionar o seguinte texto marcação para o arquivo, basta seguir o último elemento Field e recuado no mesmo nível como os vários elementos Field campo:
```
                          <RenderPattern name="DisplayPattern">
  <Switch>
    <Expr>
      <Column/>
    </Expr>
    <Case value="">
    </Case>
    <Default>
      <HTML><![CDATA[ISBN&nbsp;]]></HTML>
      <Column HTMLEncode="TRUE"/>
    </Default>
  </Switch>
</RenderPattern>
```
Este elemento RenderPattern RenderPattern do DisplayPattern DisplayPattern tipo processa o campo na lista Modos de Exibição e no modo de exibição. Se um seqüência vazia o valor do campo (representado pelo elemento Column coluna), ele não executa nenhuma função. Se o campo tiver um valor, a palavra "ISBN" é processado, seguido por um espaço e, em seguida, o valor do campo. O cabeçalho de coluna no modo exibição de lista é processado por um HeaderPattern RenderPattern RenderPattern HeaderPattern que a personalizado tipo de campo será herdam suas tipo de campo "texto" pai. (Para obter mais informações sobre padrões processar, consulte Elemento RenderPattern (tipos de campos)).

Aviso

Não use o implantar opção no menu construir do Visual Studio, se você estiver trabalhando com versão 1.0 de Windows SharePoint Services 3.0 ferramentas: as extensões Visual Studio 2005.Fazendo caso será criado um arquivo simplificado fldtypes*.xml fldtypes*.XML a ser implantado no local a um de causar.A versão simplificado não conterá o personalizado modelo RenderPattern RenderPattern.

Criar e testar o tipo de campo personalizado

Para compilar e testar o personalizado tipo de campo

Selecione recriar sobre o menu construir. Devido os comandos Post-Build criada anteriormente, essa copiar automaticamente será o vários arquivos em que eles precisam ser.
Abra um site no seu aplicativo da Web SharePoint e criar uma lista chamado manuais.
Adicione uma nova coluna a de lista. Na página a Create Column, digite "ISBN" como a nome da coluna.
Clique no botão de opção para ISBN para um catálogo .
Clique no botão de opção ' Sim ' para tornar o campo exigido.
Deixe o adicionar usar como padrão exibição caixa de seleção habilitado.
Clique em OK .
Adicione um item à lista.
Sobre a página New Item, verificar que o campo é inicialmente definido para o valor usar como padrão "0-000-00000-0".
Digite inválido valores ISBN para ver que tipo de erros Você get quando você tenta salvar o item.
Veja o que acontece se você deixar o campo inteiramente em branco.
Finalmente, digite 0-262-61108-2 ou outro valor que você sabe é válido e clique OK . (Se você erros get para um válido ISBN, verifique se há não espaço em branco ao final de valor.)
Confirme que o valor no exibição de lista é precedido por "ISBN" e um espaço.
Clique no título item para a página de exibição aberto. Confirme que o campo processa da mesma maneira que ele processa em exibição de lista.
Clique em Editar Item para editar o campo. Confirme se o campo é inicialmente definido como seu atual valor, não a usar como padrão.
Alterar o campo Para inválido valores e confirmar que os erros validação aparecem no modo Editar apenas como tinham no novo modo.

Como o campo de processamento para dispositivos móveis difere do processamento de campos para computadores

Em Windows SharePoint Services 3.0, processamento campo com personalizado campo processamento Controles para dispositivos móveis é semelhante ao campo processamento com personalizado campo processamento Controles para computadores. Mas manter essas diferenças em mente:

Páginas móveis são um conjunto inteiramente diferente de páginas a partir das páginas principais de um site Windows SharePoint Services wssnoversshort (que são criadas para navegadores computador) e que eles fazem referência um conjunto diferente de objetos RenderingTemplate T:Microsoft.SharePoint.WebControls.RenderingTemplate.
Objetos móvel RenderingTemplate T:Microsoft.SharePoint.WebControls.RenderingTemplate são declarados em MobileDefaultTemplates.ascx, não DefaultTemplates.ascx.
Campo móvel processamento Controles tem seu próprio espaço para nome, Microsoft.SharePoint.MobileControls e eles derivar de classes de ASP.NET System.Web.UI.MobileControls namespace (em vez de espaço para nome System.Web.UI.WebControls N:System.Web.UI.WebControls).
Hierarquia de herança para controles processamento campo móvel é um pouco diferente do regular campo processamento Controles. For example, the functions of the TemplateBasedControl and FormComponent in regular field rendering are combined in the SPMobileComponent class.
Campo Personalizado processamento controles que você cria para mais contextos móveis dependem de CreateChildControls CreateChildControls método do controle para processar um campo e correspondentemente menor no modelo de processamento, que é a maiúsculas e minúsculas para personalizado campo processamento controles que você cria para navegadores computador. Além disso, quando estiver desenvolvendo personalizado móvel processamento Controles você irá substituir não freqüentemente o CreateChildControls método próprio. Em vez disso, seu personalizado controles móveis processamento irão substituir geralmente um ou mais dos quatro métodos que estão chamado pelo CreateChildControls CreateChildControls método:

Próxima etapas

Quando seu personalizado tipo de campo é testados, adicionar um wssversion3short Windows SharePoint Services 3.0 solução para o projeto Visual Studio para que você possa facilmente implantar para servidores de produção. Para obter mais informações, consulte Visão geral sobre soluções.

Consulte também

Referência

Field Rendering Templates
Elemento FieldTypes (tipos de campos)
Elemento FieldType (tipos de campos)
Elemento de campo (tipos de campos)
Namespace Naming Guidelines
Elemento RenderPattern (tipos de campos)
AlternateTemplateName
BaseValidator
ControlTemplate
CreateChildControls
DefaultAlternateTemplateName
DefaultTemplateName
EnsureChildControls
FieldRenderingControl
GetValidatedString
ItemFieldValue
Label
OnLoad
RegularExpressions
RenderingTemplate
SPControlMode
SPFieldText
SPFieldValidationException
Template
TemplateName
TextBox
TextField
ValidationRule
Value

Conceitos

Classes do campo personalizado
Definição Tipo de campo personalizado
Implantação tipos de campo personalizado
A validação de dados do campo personalizado
Campo de Processamento Controles
Padrões de processamento do campo personalizado
Visão geral sobre soluções

Share via