Simple File watcher using FileSystemWatcher in C#

static void Main(string[] args)
        {
            FileSystemWatcher fs = new FileSystemWatcher();
            fs.Path = @"D:\AAS\";
            fs.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName;
            fs.Created += new FileSystemEventHandler(fs_Changed);
            fs.Changed += new FileSystemEventHandler(fs_Changed);
            fs.EnableRaisingEvents = true;
            Console.ReadKey();
        }

        static void fs_Changed(object sender, FileSystemEventArgs e)
        {
            Console.WriteLine(e.FullPath);
            File.Delete(e.FullPath);
        }

Events and Delegates using C#

Delegate, Enum and Event Arguments:

public delegate void TimeSheetRejectedDelegate(TimeSheetEventArgs e);
    public enum Status
    {
        New = 0,
        Saved = 1,
        Submitted = 2,
        Approved = 3,
        Rejected = 4
    }
    public class TimeSheetEventArgs : EventArgs
    {
        long _timesheetId = 0;
        DateTime _timesheetDate = default(DateTime);
        Status _status = 0;
        string _message = string.Empty;

        public long TimeSheetId
        {
            get { return _timesheetId; }
        }

        public DateTime TimeSheetDate
        {
            get { return TimeSheetDate; }
        }

        public Status TimeSheetStatus
        {
            get { return _status; }
        }

        public string Message
        {
            get { return _message; }
        }

        public TimeSheetEventArgs(long timesheetId, DateTime timesheetDate, Status status, string MessageText)
        {
            this._timesheetId = timesheetId;
            this._timesheetDate = timesheetDate;
            this._status = status;
            this._message = MessageText;
        }
      
    }

Business Entity with Event:

public class TimeSheet
    {
        long _timesheetId = 0;
        DateTime _timesheetDate = default(DateTime);
        Status _status = 0;
       
        public event TimeSheetRejectedDelegate TimeSheetRejected;
               
        public long TimeSheetId
        {
            get { return _timesheetId; }
        }

        public DateTime TimeSheetDate
        {
            get { return TimeSheetDate; }
        }

        public Status TimeSheetStatus
        {
            get { return _status; }
        }

        public void AddTimeSheet(long timesheetId, DateTime timesheetDate, Status status)
        {
            this._timesheetId = timesheetId;
            this._timesheetDate = timesheetDate;
            this._status = status;
            if (status == Status.Rejected)
                DispatchTimeSheetRejectedEvent("Timesheet is added with Rejected Status");
        }

        public void ChangeTimeSheetStatus(long timesheetId, Status status)
        {
            if (status == Status.Rejected)
                DispatchTimeSheetRejectedEvent("Timesheet is updated with Rejected Status");
        }

        void DispatchTimeSheetRejectedEvent(string MessageText)
        {
            if (TimeSheetRejected != null)
            {
                TimeSheetRejected(new TimeSheetEventArgs(_timesheetId, _timesheetDate, _status,
                    MessageText));
            }
        }

       
    }

Invoking Point:

TimeSheet time1 = new TimeSheet();
            time1.TimeSheetRejected += new TimeSheetRejectedDelegate(time1_TimeSheetRejected);
            time1.AddTimeSheet(1, DateTime.Now,Status.New);
            time1.ChangeTimeSheetStatus(1, Status.Rejected);
            time1.AddTimeSheet(2, DateTime.Now, Status.Rejected);
            Console.ReadKey();

Search a text in tables using SQL Query

CREATE PROC FindAllTables
(
    @SearchStr nvarchar(100)
)
AS
BEGIN

   

    CREATE TABLE #Results (ColumnName nvarchar(370), ColumnValue nvarchar(3630))

    SET NOCOUNT ON

    DECLARE @TableName nvarchar(256), @ColumnName nvarchar(128), @SearchStr2 nvarchar(110)
    SET  @TableName = ''
    SET @SearchStr2 = QUOTENAME('%' + @SearchStr + '%','''')

    WHILE @TableName IS NOT NULL
    BEGIN
        SET @ColumnName = ''
        SET @TableName =
        (
            SELECT MIN(QUOTENAME(TABLE_SCHEMA) + '.' + QUOTENAME(TABLE_NAME))
            FROM     INFORMATION_SCHEMA.TABLES
            WHERE         TABLE_TYPE = 'BASE TABLE'
                AND    QUOTENAME(TABLE_SCHEMA) + '.' + QUOTENAME(TABLE_NAME) > @TableName
                AND    OBJECTPROPERTY(
                        OBJECT_ID(
                            QUOTENAME(TABLE_SCHEMA) + '.' + QUOTENAME(TABLE_NAME)
                             ), 'IsMSShipped'
                               ) = 0
        )

        WHILE (@TableName IS NOT NULL) AND (@ColumnName IS NOT NULL)
        BEGIN
            SET @ColumnName =
            (
                SELECT MIN(QUOTENAME(COLUMN_NAME))
                FROM     INFORMATION_SCHEMA.COLUMNS
                WHERE         TABLE_SCHEMA    = PARSENAME(@TableName, 2)
                    AND    TABLE_NAME    = PARSENAME(@TableName, 1)
                    AND    DATA_TYPE IN ('char', 'varchar', 'nchar', 'nvarchar')
                    AND    QUOTENAME(COLUMN_NAME) > @ColumnName
            )
   
            IF @ColumnName IS NOT NULL
            BEGIN
                INSERT INTO #Results
                EXEC
                (
                    'SELECT ''' + @TableName + '.' + @ColumnName + ''', LEFT(' + @ColumnName + ', 3630)
                    FROM ' + @TableName + ' (NOLOCK) ' +
                    ' WHERE ' + @ColumnName + ' LIKE ' + @SearchStr2
                )
            END
        END   
    END

    SELECT ColumnName, ColumnValue FROM #Results
END



GO


--exec FindAllTables 'activitylog'

Sample StyleCop custom rules

Methods should not have more then 200 lines of code:

private void MethodShouldNotHaveMoreThanTwoHundredLines(CsElement element, CsElement parentElement)
        {
            if ((!element.Generated && (element.Declaration != null)) && (element.Declaration.Name != null))
            {
                switch (element.ElementType)
                {
                    case ElementType.Method:
                        //Checking 203 line as first line for method declaration and two lines for opening and closing parenthesis '{','}'
                        if (element.Location.LineSpan > 203)
                        {
                            base.AddViolation(element, "MethodShouldNotHaveMoreThanTwoHundredLines");
                        }
                        break;
                }
            }

        }

Prefix Private variables with underscore:

private void PrefixPrivateVariableNameWithUnderScore(CsElement element, CsElement parentElement)
        {
            // Flag a violation if the instance variables are not prefixed with an underscore.
            if (!element.Generated && element.ElementType == ElementType.Field && element.ActualAccess == AccessModifierType.Private &&
                 element.Declaration.Name.ToCharArray()[0] != '_')
            {
                //If field type is "const" than Pascal casing rule is applicable on it.
                if (((Field)element).Const) return;

                base.AddViolation(element, "PrefixPrivateVariableNameWithUnderScore");
            }
            else if (!element.Generated && element.ElementType == ElementType.Field && element.ActualAccess == AccessModifierType.Private
                && CheckCase(element.Declaration.Name.Substring(1), false))
            {
                base.AddViolation(element, "PrefixPrivateVariableNameWithUnderScore");
            }

        }

Avoid specifying type for Enum:

private void AvoidSpecifyingEnumType(CsElement element, CsElement parentElement)
        {
            if (element.ElementType == ElementType.Enum)
            {
                Microsoft.StyleCop.CSharp.Enum enm = (Microsoft.StyleCop.CSharp.Enum)element;
                if (enm.BaseType != null)
                {
                    base.AddViolation(element, "AvoidSpecifyingEnumType", new object[0]);
                }
            }
        }

Camel casing for local variable names and method arguments:

private void CamelCasingForMethodArgumentsAndLocalVariable(CsElement element, CsElement parentElement)
        {
            if (element.ElementType == ElementType.Method)
            {
                foreach (Variable tempVariable in element.Variables)
                {
                    //If argument type is 'EventArgs' allow non-Camel case variable name also.
                    if (!tempVariable.Type.Text.ToLower().EndsWith("EventArgs".ToLower()))
                    {
                        if (CheckFieldUnderscores(tempVariable.Name) || CheckCase(tempVariable.Name, false))
                        {
                            base.AddViolation(element, tempVariable.Location.LineNumber, "CamelCasingForMethodArgumentsAndLocalVariable");

                        }
                    }
                }
            }


        }

Avoid abbrivated character variable names, such as i, num, tmp:

private void AvoidAbbrivatedCharacterVariableNames(CsElement element, CsElement parentElement)
        {
            if (element.ElementType == ElementType.Field)
            {
                if (element.Declaration.Name.Length <= 3)
                    base.AddViolation(element, "AvoidAbbrivatedCharacterVariableNames", new object[0]);
            }
            if (element.ElementType == ElementType.Method)
            {
                foreach (Variable elem in element.Variables)
                {
                    if (!elem.Type.Text.ToLower().EndsWith("EventArgs".ToLower()))
                    {
                        if (elem.Name.Length <= 3)
                            base.AddViolation(element, elem.Location.LineNumber, "AvoidAbbrivatedCharacterVariableNames", new object[0]);
                    }
                }
            }   
        }

Using directive inside namespace:

private void UsingDirectiveOutSideOfNameSpace(CsElement element, CsElement parentElement)
        {
            if (!element.Generated && (element.ElementType == ElementType.UsingDirective))
            {
                // CsElement parentElement = element.ParentElement;
                if ((parentElement != null) && (parentElement.ElementType == ElementType.Namespace))
                {

                    AddViolation(element, "UsingDirectiveShouldOutSideOfNameSpace");

                }
            }
        }

XML Transformation using XSLT

public static XmlElement Transfomer(string xsltFilePath, XmlDocument bericht)
        {
            XslCompiledTransform transformer = new XslCompiledTransform();
            XsltSettings xsltSettings = new XsltSettings(false, true);
            transformer.Load(xsltFilePath, xsltSettings, new XmlUrlResolver());



            XmlDocument transformedMessage = new XmlDocument();

            using (MemoryStream memoryStream = new MemoryStream())
            {
                XmlWriterSettings writerSettings = new XmlWriterSettings();
                writerSettings.Indent = true;
                writerSettings.IndentChars = "\t";
                writerSettings.Encoding = System.Text.Encoding.UTF8;
                writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
                writerSettings.OmitXmlDeclaration = true;

                XmlWriter writer = XmlWriter.Create(memoryStream, writerSettings);

                transformer.Transform(bericht, writer);
                writer.Flush();
                memoryStream.Position = 0;
                transformedMessage.Load(memoryStream);
            }

            return transformedMessage.DocumentElement;
        }