C#

namespace ClientMessages
{
    [Serializable]
    abstract public class BaseMessageClass
    {
        // common stuff of type int, string and an enum
        public int type;
    }
}

namespace OverarchingServer
{
    using ClientMessages;

    public enum MessageTypeEnum : int
    {
        DerivedMessageType = 1,
        AnotherType,
        YetAnotherType
    }

    [Serializable]
    public class DerivedMessage : BaseMessageClass
    {
        // specific stuff including a structure { Guid, string, int } and an enum
    }

    public class SendingServer
    {
        private Socket client;      // opened in code not shown

        public void DoingWork ()
        {
            DerivedMessage msg = new DerivedMessage ();
            // fill the fields
            this.Send (msg);
        }

        public void Send (BaseMessageClass msg)
        {
            MemoryStream mem = new MemoryStream ();
            BinaryFormatter bf = new BinaryFormatter ();

            bf.Serialize (mem, msg);
            byte[] data = mem.ToArray ();

            NetworkStream stream = new NetworkStream (this.client);
            BinaryWriter binWrite = new BinaryWriter (stream);

            binWrite.Write ((Int32) data.Length);
            binWrite.Write (data, 0, data.Length);
        }
    }

    public class ReceivingServer
    {
        private Socket client;  // opened in code not shown

        private void LoopWithDetailsOmitted ()
        {
            NetworkStream stream = new NetworkStream (this.client);
            BinaryReader binRead = new BinaryReader (stream);

            int length;
            byte[] data;

            length = binRead.ReadInt32 ();
            data = binRead.ReadBytes (length);

            MemoryStream mem = new MemoryStream (data);
            BinaryFormatter bf = new BinaryFormatter ();

            BaseMessageClass msg = (BaseMessageClass) bf.Deserialize (mem);

            this.HandleMessage (msg);
        }

        private void HandleMessage (BaseMessageClass msg)
        {
            MessageTypeEnum type = (MessageTypeEnum) msg.type;

            switch (type)
            {
                case MessageTypeEnum.DerivedMessageType:
                    this.HandleMessage ((DerivedMessage) msg);      // *****
                    break;
            }
        }

        private void HandleMessage (DerivedMessage msg) { }
    }
}

private void getAllFiles(string sExt, string sFolder)
{
    DirectoryInfo di = new DirectoryInfo(sFolder);
    FileInfo[] fi = di.GetFiles(sExt, SearchOption.AllDirectories);
    //List<FileInfo> fi = new List<FileInfo>(di.EnumerateFiles(sExt, SearchOption.AllDirectories));
    foreach (FileInfo file in fi)
    {
        AddNewFile(Path.Combine(di.ToString(), file.ToString()));
        counter++;
    }
    lblTotalFiles.Text = counter.ToString();
    //SetText(counter.ToString());
}

public enum Type
    {
        None = 0,
        Found =1,
        NotAval = 2
        
    };

public enum ShortType
    {
        None = 0,
        Fd =1,
        NA = 2
    };


class Properties
{
public Type type;
};

 List<Properties> props;
//After that List is populated
...
...
//Now I want to type cast the Type enum in the entire list to ShortType with out looping through the entire list 
//Please advice