C#

LinkLabel.Font.Underline = false

LimitedRemoteResource res = null;
try
{
    res = new LimitedRemoteResource();
    res.Allocate();

    this.MethodDoesSomething(res,argsA);
    this.SomeOtherMethodDoesSomething(res,argsB);
    ....
    // somewhere along the way the application goes poof!
    ....
}
finally
{
    // if something really bad happens this doesn't get called anyway
    if(res != null)
        res.Release();
}

public bool UpdateThePriveledge(object orignalValue, object newValue)
{
  lock
  {
     try{
        res = new LimitedRemoteResource();
        res.Allocate();
        this.MethodDoesSomething(res,argsA);
        this.SomeOtherMethodDoesSomething(res,argsB);
        ....
       // somewhere along the way the application goes poof!
       // I hate when that happens
        ....

  }
  finally
  {
       // if something really bad happens this doesn't get called anyway
       if(res != null)
         res.Release();
  }
 }

 public bool PublishIdentity(string name)
 {
 }
 public void NotifyServer(string name)
 {
 }

public class MyClass : ICustomTypeDescriptor
{
  // ...
  TypeConverter ICustomTypeDescriptor.GetConverter()
  {
    return TypeDescriptor.GetConverter(this, true);
  }
  // ...
}

public class Secure : ICustomTypeDescriptor
{
     private bool isSecure;

     public Secure(bool state)
     {
         isSecure = state;
     }

     .. now I'm lost trying to deploy everything
}

namespace myCompany.Attributes
{

	internal class Secured  : ICustomTypeDescriptor 
	{
		private bool secured;
		private bool readonlyState;


		/// <summary>
		/// Create an attribute Secured(true/false)
		/// </summary>
		/// <param name="state"></param>
		public Secured(bool state) 
		{
			secured = state;
		}


		/// <summary>
		/// Returns attribute ReadOnly(true) if user is not in any security group.
		/// Returns attribute ReadOnly(true) if Secured(true) and user is editor.
		/// Always returns attribute ReadOnly(false) if user is developer.
		/// </summary>
		/// <returns></returns>
		System.ComponentModel.PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(System.Attribute[]
			attributes)
		{


			PropertyInfo[] propInfos =
				this.classType.GetProperties(BindingFlags.Public | BindingFlags.Static);

			ArrayList props = new ArrayList(propInfos.Length);

			foreach(PropertyInfo propInfo in propInfos)
			{
				props.Add( new ReflectPropertyDescriptor(propInfo) );
			}
			if (CheckReadOnlyState())
				props.Add(new ReflectProperty(???));
			return new PropertyDescriptorCollection(
				(PropertyDescriptor[])props.ToArray(typeof(PropertyDescriptor)) );

		}
		System.ComponentModel.PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
		{
			ArrayList props = new ArrayList();
			if (CheckReadOnlyState())
				props.Add(new ReflectPropertyDescriptor(PropertyDescriptor.ReadOnly));
                        return new PropertyDescriptorCollection((PropertyDescriptor[])props.ToArray(typeof(PropertyDescriptor)));
		}
			

		TypeConverter ICustomTypeDescriptor.GetConverter()
		{
			return TypeDescriptor.GetConverter(this, true);
		}

		AttributeCollection ICustomTypeDescriptor.GetAttributes()
		{
			return TypeDescriptor.GetAttributes(this.secured, true);
		}


		/// <summary>
		/// Tell PropertyGrid that GetProperties is supported.
		/// </summary>
		/// <param name="context"></param>
		/// <returns></returns>
		public  bool GetPropertiesSupported(ITypeDescriptorContext context) 
		{
			return true;
		}
		object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
		{

		}
	}

        public class bool CheckReadOnlyState()
        {
            readonlyState = true;
	    SecurityManager sec = new SecurityManager();

	    if (sec.CheckUserGroup("D-U-TCAEDIT") && !this.secured)
	    {
		readonlyState = false;
	    }
	    if (sec.CheckUserGroup("D-U-TCA"))
	    {
		readonlyState = false;
	    }
            return readonlyState;
        }
	public class PropertyDescriptor ReflectPropertyDescriptor : PropertyDescriptor
	{
		private PropertyInfo propInfo;

		public ReflectPropertyDescriptor(PropertyInfo propInfo) :
			base(propInfo.Name, null)
		{
			this.propInfo = propInfo;
		}
	}