Kasım 2009
M	T	W	T	F	S	S
« Oct
	1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30

‘Enum’ Kategorisi için Arşiv

FieldInfo.IsStatic Property

Yazan: esersahin 06/10/2009

http://msdn.microsoft.com/en-us/library/system.reflection.fieldinfo.isstatic(VS.80).aspx

using System;
using System.Reflection;

// Make two fields.
public class Myfielda
{
    private string field = “A private field”;
    public string Field
    {
        get{return field;}
        set{if(field!=value){field=value;}}
    }
}
public class Myfieldb
{
    static string field = “B private static field”;
    public string Field
    {
        get{return field;}
        set{if(field!=value){field=value;}}
    }
}

public class Myfieldinfo
{
    public static int Main()
    {
        Console.WriteLine(“\nReflection.FieldInfo”);
        Myfielda Myfielda = new Myfielda();
        Myfieldb Myfieldb = new Myfieldb();

        // Get the Type and FieldInfo.
        Type MyTypea = typeof(Myfielda);
        FieldInfo Myfieldinfoa = MyTypea.GetField(“field”, BindingFlags.NonPublic|BindingFlags.Instance);
        Type MyTypeb = typeof(Myfieldb);
        FieldInfo Myfieldinfob = MyTypeb.GetField(“field”, BindingFlags.NonPublic|BindingFlags.Static);

        // For the first field, get and display the name, field, and IsStatic property value.
        Console.Write(“\n{0} – “, MyTypea.FullName);
        Console.Write(“{0}; “, Myfieldinfoa.GetValue(Myfielda));
        Console.Write(“IsStatic – {0}”, Myfieldinfoa.IsStatic);

        // For the second field get and display the name, field, and IsStatic property value.
        Console.Write(“\n{0} – “, MyTypeb.FullName);
        Console.Write(“{0}; “, Myfieldinfob.GetValue(Myfieldb));
        Console.Write(“IsStatic – {0}”, Myfieldinfob.IsStatic);

        return 0;
    }
}

Yazı kategorisi: Enum, FieldInfo | » yorum bırak;

FieldInfo Class

Yazan: esersahin 06/10/2009

http://msdn.microsoft.com/en-us/library/system.reflection.fieldinfo(VS.80).aspx

Copy Code

using System;
using System.Reflection;

public class FieldInfoClass
{
    public int myField1 = 0;
    protected string myField2 = null;
    public static void Main()
    {
        FieldInfo[] myFieldInfo;
        Type myType = typeof(FieldInfoClass);
        // Get the type and fields of FieldInfoClass.
        myFieldInfo = myType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance
            | BindingFlags.Public);
        Console.WriteLine("\nThe fields of " +
            "FieldInfoClass are \n");
        // Display the field information of FieldInfoClass.
        for(int i = 0; i < myFieldInfo.Length; i++)
        {
            Console.WriteLine("\nName            : {0}", myFieldInfo[i].Name);
            Console.WriteLine("Declaring Type  : {0}", myFieldInfo[i].DeclaringType);
            Console.WriteLine("IsPublic        : {0}", myFieldInfo[i].IsPublic);
            Console.WriteLine("MemberType      : {0}", myFieldInfo[i].MemberType);
            Console.WriteLine("FieldType       : {0}", myFieldInfo[i].FieldType);
            Console.WriteLine("IsFamily        : {0}", myFieldInfo[i].IsFamily);
        }
    }
}

Yazı kategorisi: Enum, FieldInfo | » yorum bırak;

Enum List DropDown Control

Yazan: esersahin 10/10/2008

http://jeffhandley.com/archive/2008/01/27/enum-list-dropdown-control.aspx

I’ve been wanting to try this concept out for awhile, and I finally had a reasonable opportunity. The idea was to slap a System.ComponentModel.Description attribute onto each field of an Enum, and then bind a dropdown list directly to the Enum.

I got it working and the code is pretty concise. Please excuse the fact that I’m working in VB for this one; it’s my DotNetNuke project, and I was already working in VB to edit some modules. The code would be even prettier in C# I imagine.

First, let’s decorate an enum. Import System.ComponentModel here.

Public Enum RegionCode
    <Description("-- Select --")> NotSelected = 0
    <Description("US - Midwest")> Midwest = 1
    <Description("US - Northeast")> Northeast = 2
    <Description("US - Southeast")> Southeast = 3
    <Description("US - Southwest")> Southwest = 4
    <Description("US - West")> West = 5
    Canada = 6
End Enum

Next, we need to build a helper routine that can get the description off of a decorated enum field. It must gracefully handle the case when a description is not specified, as with Canada.

In .NET 3.5, you’d probably want to build these as extension methods, which would be a trivial change. Import System.ComponentModel here too.

''' <summary>
''' Get the Description of an enum value
''' </summary>
''' <param name="value"></param>
''' <returns></returns>
''' <remarks>If there is no description attribute, the name will be used.</remarks>
Public Function GetDescription(ByVal value As System.Enum) As String
    Return GetDescription(value.GetType().GetField(value.ToString))
End Function

''' <summary>
''' Get the description of a field
''' </summary>
''' <param name="field"></param>
''' <returns></returns>
''' <remarks>If the field doesn't have a description attribute, the name is used</remarks>
Public Function GetDescription(ByVal field As System.Reflection.FieldInfo)
    ' Get the array of description attributes applied (there will be 0 or 1)
    Dim descriptions() As Object
    descriptions = field.GetCustomAttributes(GetType(DescriptionAttribute), False)

    ' If there was a description, return it
    If descriptions.Length > 0 Then
        Return DirectCast(descriptions(0), DescriptionAttribute).Description
    End If

    ' Otherwise return the field's name
    Return field.Name
End Function

Now that we can easily grab the description from an enum field, let’s build ourselves a new dropdown control.

Imports System.Reflection

''' <summary>
''' A custom dropdown that binds to an enum
''' </summary>
''' <remarks>
''' The DataSource is set to an Enum type name, not a collection,
''' and it can be set within the markup if desired
''' <example><![CDATA[
'''     <app:EnumList Runat="server" ID="ddlRegion" DataSource="MyApp.RegionCode" />
'''     ...
'''     ddlRegion.DataBind()
'''     ddlRegion.SelectedValue = RegionCode.West
''' ]]></example>
''' </remarks>
Public Class EnumList
    Inherits System.Web.UI.WebControls.DropDownList

    Private _enumType As Type
    ''' <summary>
    ''' Specify the enum type that we'll bind to
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shadows Property DataSource() As String
        Get
            Return _enumType.ToString
        End Get
        Set(ByVal value As String)
            _enumType = System.Type.GetType(value, True, True)
        End Set
    End Property

    ''' <summary>
    ''' Replace SelectedValue with an Enum-based version
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shadows Property SelectedValue() As System.Enum
        Get
            ' Get the value from the request to allow for disabled viewstate
            Dim RequestValue As String = Me.Page.Request.Params(Me.UniqueID)

            Return System.Enum.Parse(_enumType, RequestValue)
        End Get
        Set(ByVal value As System.Enum)
            MyBase.SelectedValue = value.ToString
        End Set
    End Property

    ''' <summary>
    ''' Replace DataBind so that we can bind to the list of fields in the
    ''' enum.  Call our GetDescription function for each one to get the
    ''' text to display.
    ''' </summary>
    ''' <remarks></remarks>
    Public Overrides Sub DataBind()
        Me.Items.Clear()
        Dim flags As BindingFlags = BindingFlags.Public Or BindingFlags.Static

        For Each field As FieldInfo In _enumType.GetFields(flags)
            Me.Items.Add(New ListItem(GetDescription(field), field.Name))
        Next
    End Sub

End Class

The usage is quite simple, as the example in the comment shows. Here’s the markup for the control:

   1: <app:EnumList Runat="server" ID="ddlRegion" DataSource="MyApp.RegionCode" />

And in the code-behind, it’s wired up as follows:

   1: ddlRegion.DataBind()
   2: ddlRegion.SelectedValue = RegionCode.West

Here’s the result. I chose to have the value of the dropdown be the enum field name rather than its value, because that felt cleaner.

<select name="dnn$ctr396$ManageJobs$ddlRegion" id="dnn_ctr396_ManageJobs_ddlRegion">
    <option value="NotSelected">-- Select --</option>
    <option value="Midwest">US - Midwest</option>
    <option value="Northeast">US - Northeast</option>
    <option value="Southeast">US - Southeast</option>
    <option value="Southwest">US - Southwest</option>
    <option selected="selected" value="West">US - West</option>
    <option value="Canada">Canada</option>
</select>

I suspect that there are going to be some goofy bugs in here if this was hit with some complex scenarios. But fortunately for me, this project won’t have any complex scenarios.

Yazı kategorisi: Enum | » yorum bırak;

Extending the DropDownList to Support Enums

Yazan: esersahin 10/10/2008

Introduction -> http://aspalliance.com/1514_Extending_the_DropDownList_to_Support_Enums.all

A fairly common task in some of the applications I work with is to provide a user with a DropDownList of options that is populated by an enum. This can easily be done with a little bit of code to bind a stock DropDownList control to the enum, but this kind of thing quickly starts to violate the DRY (Don’t Repeat Yourself) principle, so I created a simple derived DropDownList control that takes advantage of Generics to make it especially effective and require less code and casting of data types.

Binding a Standard DropDownList to an Enum

Before we delve into the derived DropDownList, consider the code that it is meant to replace. Let’s say that we have an enum that describes Status, and has possible values of Active, Inactive, Pending, and Declined. We’ll say these are for Proposal, so we’ll call the enum ProposalStatus.

Listing 1: ProposalStatus enum

public enum ProposalStatus
{
  Active =1,
  Inactive = 2,
  Pending = 3,
  Declined = 4
}

Now if we want to render a DropDownList that uses this enum as its data source, we would use code like the following:

Listing 2: Binding Names to DropDownList

if (!Page.IsPostBack)
{
  ProposalStatusDropDownList.DataSource = 
  Enum.GetNames(typeof(ProposalStatus));
  ProposalStatusDropDownList.DataBind();
}

This will render a DropDownList with display and value both as the name of the enum – the value is not stored in the DropDownList. To get at the value, you would use code like this:

Listing 3: Getting a Strongly Typed Enum Value from the DropDownList

protected void Button1_Click(object sender, EventArgs e)
{
  ProposalStatus myStatus = (ProposalStatus)Enum.Parse(
    typeof(ProposalStatus), ProposalStatusDropDownList.SelectedValue);
  Label1.Text = myStatus.ToString();
}

Of course, if you actually want to store the enum’s numeric value as the value of the DropDownList, the most effective way to achieve that is to load up a SortedList<int,string> with the values and their corresponding names, and then DataBind to this collection. This is easily done with a helper method like the one shown in Listing 4. Note that since we cannot use where T:System.Enum the best we can do is constrain T to be a struct and then do a type check in code to verify it inherits from Enum.

Listing 4: Convert Enum to SortedList<string,int> Collection

public static SortedList<string, int> GetEnumDataSource<T>() where T:struct
{
    Type myEnumType = typeof(T);
    if (myEnumType.BaseType != typeof(Enum))
    {
        throw new ArgumentException("Type T must inherit from System.Enum.");
    }

    SortedList<string, int> returnCollection = new SortedList<string, int>();
    string[] enumNames = Enum.GetNames(myEnumType);
    for (int i = 0; i < enumNames.Length; i++)
    {
        returnCollection.Add(enumNames[i],
            (int)Enum.Parse(myEnumType, enumNames[i]));
    }
    return returnCollection;
}

Then to use this method with a DropDownList we would use code like what is shown in Listing 5.

Listing 5: Bind to SortedList from Enum

ProposalStatusDropDownList2.DataSource =
GetEnumDataSource<ProposalStatus>();
ProposalStatusDropDownList2.DataValueField = "Value";
ProposalStatusDropDownList2.DataTextField = "Key";
ProposalStatusDropDownList2.DataBind();

Creating a Generic Enum DropDownList

Now that we’ve written a bunch of code to show how anybody can do this to a stock DropDownList control, let’s roll all of this code into a single reusable control, the EnumDropDownList. One additional requirement we’ll add to this control is that it optionally include a ListItem that simple displays “All” and has no associated enum value. We’ll use this when the DropDownList is being used to display filters on search results or reports, and in this case the “All” value will mean that we don’t want to filter by this enum. Similarly, to make our filtering easier, we’ll also include a nullable integer property, SelectedIntegerValue, since the data access layer is going to expect integer values for the statuses we choose to filter on (or null if none). The control will include the GetEnumDataSource<T> method shown earlier, and of course this could be refactored out into a separate utility class where it would make more sense. I’ve included it in EnumDropDownList to make the sample easier to follow. The complete source for EnumDropDownList is shown in Listing 6.

Listing 6: EnumDropDownSource

public class EnumDropDownList<T> : DropDownList where T : struct
{
    private bool _showAllOption = true;
    public bool ShowAllOption
    {
        get
        {
            return _showAllOption;
        }
        set
        {
            _showAllOption = value;
        }
    }
    public new T? SelectedValue
    {
        get
        {
            if (String.IsNullOrEmpty(this.SelectedItem.Text))
            {
                return null;
            }
            return (T)Enum.Parse(typeof(T), this.SelectedItem.Text);
        }
    }
    public int? SelectedIntegerValue
    {
        get
        {
            if (ShowAllOption && this.SelectedIndex == 0)
            {
                return null;
            }
            if (String.IsNullOrEmpty(this.SelectedItem.Text))
            {
                return null;
            }
            return (int)Enum.Parse(typeof(T), this.SelectedValue.ToString());
        }
    }

    protected override void OnInit(EventArgs e)
    {
        base.OnInit(e);
        if (typeof(T).BaseType != typeof(Enum))
        {
            throw new ArgumentException("Type T must inherit from System.Enum.");
        }
        BindData();
    }

    protected void BindData()
    {
        this.DataSource = GetEnumDataSource<T>();
        this.DataTextField = "Key";
        this.DataValueField = "Value";
        this.DataBind();
        if (ShowAllOption)
        {
            this.Items.Insert(0, new ListItem("All", ""));
        }
    }

    public static SortedList<string, int> GetEnumDataSource<T>() where T : new()
    {
        Type myEnumType = typeof(T);
        if (myEnumType.BaseType != typeof(Enum))
        {
            throw new ArgumentException("Type T must inherit from System.Enum.");
        }

        SortedList<string, int> returnCollection = new SortedList<string, int>();
        string[] enumNames = Enum.GetNames(myEnumType);
        for (int i = 0; i < enumNames.Length; i++)
        {
            returnCollection.Add(enumNames[i],
                (int)Enum.Parse(myEnumType, enumNames[i]));
        }
        return returnCollection;
    }
}

Now to use this control, unfortunately you can’t simply add markup to the ASPX page. Some options were discussed by Mikhail at Microsoft but I can’t find that anything was ever implemented up through ASP.NET 3.5. Thus, you can only instantiate this control from your C# or VB code, and then add it to the page using a Placeholder control or similar technique. This is fairly minor, however, and the resulting code in the page’s codebehind is shown in Listing 7. PlaceHolder1 is defined on the page where we want the DropDownList to be shown.

Listing 7: Rendering the Control in a PlaceHolder

protected EnumDropDownList<ProposalStatus> ProposalStatusDropDownList1;
protected override void OnInit(EventArgs e)
{
  base.OnInit(e);
  ProposalStatusDropDownList1 = new EnumDropDownList<ProposalStatus>();
  this.PlaceHolder1.Controls.Add(ProposalStatusDropDownList1);
}

[Download Sample]
Resources
[ Back To Top ] How To Bind Enum To DropDownList Use Enum as DataSource for DropDownList Generic Enum To List Converter Why We Need Where T:Enum Constraint Steve’s Blog

Yazı kategorisi: Enum | » yorum bırak;

DropDownLists with Enums as DataSource

Yazan: esersahin 10/10/2008

http://developcode.blogspot.com/2006/12/dropdownlists-with-enums-as-datasource.html

When creating DropDownLists out of enums in ASP.NET, I often tend to dislike the way the usual examples use the enum’s Values and Names as keys and values for the DropDownList. In this example, I have created an enhanced enum using DescriptionAttribute instead. This way, you can go a lot further on deciding what the visible values in a DropDownList may be – without being tied to a C# type name syntax.

This way, you can get these kinds of DropDownLists using pure enums only:

Step 1 – Enhance your enums with the Description:

using System.ComponentModel;

public enum CourierCompanies
{
[Description("Please select a courier company")]
None = -1,

[Description("Other")]
Other = 0,

[Description("DHL")]
DHL,

[Description("Action Courier")]
ActionCourier,

[Description("American Courier Express")]
ACE

}

Step 2: Create a helper class which extracts description data both for each enum value and a key/value pair for use in DataSources:

using System.ComponentModel;
using System.Reflection;

public class EnumDescription
{
/// <summary>
/// Get the description attribute for one enum value
/// </summary>
/// <param name=”value”>>Enum value
/// <returns>The description attribute of an enum, if any</returns>
public static string GetDescription(Enum value)
{
FieldInfo fieldInfo = value.GetType().GetField(value.ToString());
DescriptionAttribute[] attributes = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
return (attributes.Length > 0) ? attributes[0].Description : value.ToString();
}

/// <summary>
/// Gets a list of key/value pairs for an enum, using the description attribute as value
/// </summary>
/// <param name=”enumType”>>typeof(your enum type)
/// <returns>A list of KeyValuePairs with enum values and descriptions</returns>
public static List<KeyValuePair;<string, string>> GetValuesAndDescription(System.Type enumType)
{
List<KeyValuePair><string, string>> kvPairList = new List<KeyValuePair<string, string>>();

foreach (Enum enumValue in Enum.GetValues(enumType))
{
kvPairList.Add(new KeyValuePair<string,string>(enumValue.ToString(), GetDescription(enumValue)));
}

return kvPairList;
}
}

Step 3: Fill the DropDownList using the enum itself as a DataSource:

protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
ddlCourier.DataSource = EnumDescription.GetValuesAndDescription(typeof(CourierCompanies));
ddlCourier.DataTextField = “Value”;
ddlCourier.DataValueField = “Key”;
ddlCourier.DataBind();
}
}

The reason for using the names “Value” and “Key” is that the properties of the generic KeyValuePair type are “Value” and “Key”.

Yazı kategorisi: Enum | » yorum bırak;

using …

Pure C#

Categories

Archives

Calendar

Blog Stats

Recent Posts

Top Posts

Top Clicks

‘Enum’ Kategorisi için Arşiv

FieldInfo.IsStatic Property

FieldInfo Class

Enum List DropDown Control

Extending the DropDownList to Support Enums

DropDownLists with Enums as DataSource

using …

Pure C#

Categories

Category Cloud

Archives

Calendar

Blog Stats

Recent Posts

Top Posts

Top Clicks

‘Enum’ Kategorisi için Arşiv

FieldInfo.IsStatic Property

FieldInfo Class

Generic Enum to List converter (C#)

One for the utility library…

Enum List DropDown Control

Extending the DropDownList to Support Enums

DropDownLists with Enums as DataSource