C#

"NHapi is a port of the original project HAPI.

NHapi allows Microsoft .NET developers to easily use an HL7 2.x object model. This object model allows for parsing and encoding HL7 2.x data to/from Pipe Delimited or XML formats. A very handy program for use in the health care industry.

This project is NOT affiliated with the HL7 organization. This software just conforms to the HL7 2.x specifications.

private int whiteSpaceSeenSoFar = 0;

private void handleEnterReturn()
{
    // ??
}

private void YourRichTextBox_KeyUp(object sender, KeyEventArgs e)
{
    switch (e.KeyCode)
    {
        case Keys.OemPeriod:
            // handlePeriodEntered
            break;
        case Keys.Enter: // or the 'Return key
            handleEnterReturn();
            break;
        case Keys.Tab:
            // handle if AcceptsTab is set to 'true ?
            //handleTab();
            break;
        case Keys.Space:
            whiteSpaceSeenSoFar++;
            break;
        case Keys.Back:
            // handle backspace ?
            break;
        case Keys.Delete:
            // handle delete ?
            break;
        default:
            // every other character
            break;
    }
}

CombinationChart

PdfSharp.Charting

CombinationChart

PdfPage page = document.AddPage();
page.Size = PageSize.A4;

Chart chart = CombinationChart();

ChartFrame = new ChartFrame();
chartFrame.Location = new XPoint(30, 30);
chartFrame.Size = new XSize(500, 600);
chartFrame.Add(chart);

XGraphics gfx = XGraphics.FromPdfPage(page);
chartFrame.Draw(gfx);
document.Close();

Agent__007 wrote:

I do know that I can simply write an SP for this functionality, I want to know
if there's a way to achieve this using LINQ-to-SQL

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

 // This one is for searching in string types
private static Expression<Func<T, bool>> ContainsInStringTypeExpression<T>(string propertyName, string propertyValue)
        {
            var parameterExpression = Expression.Parameter(typeof(T), typeof(T).Name); // type => 

            var propertyExpression = Expression.PropertyOrField(parameterExpression, propertyName); // type.Name
            var stringTypeArray = new[] { typeof(String) };
            var containsMethod = typeof(String).GetMethod("Contains", stringTypeArray); // Contains method
            var valueToBeChecked = Expression.Constant(propertyValue, typeof(String)); // property value as a constant

            var finalContainsExpression = Expression.Call(propertyExpression, containsMethod, valueToBeChecked); // type.Name.Contains(propertyValue)

            return Expression.Lambda<Func<T, bool>>(finalContainsExpression, parameterExpression);
        }

// This one is for searching in numeric types
private static Expression<Func<T, bool>> ContainsInNumericTypeExpression<T>(string propertyName, string propertyValue)
        {
            var parameterExpression = Expression.Parameter(typeof(T), typeof(T).Name); // type => 

            var propertyExpression = Expression.PropertyOrField(parameterExpression, propertyName); // type.Name
            var decimalPropertyExpression = Expression.Convert(propertyExpression, typeof(System.Nullable<Decimal>)); // (decimal?)type.Name

            // SqlFunctions.StringConvert((decimal?)type.propertyName).Contains(propertyValue),
            var nullableDecimalType = new[] { typeof(System.Nullable<Decimal>) };
            var stringConvertExp = Expression.Call(null, typeof(SqlFunctions).GetMethod("StringConvert", nullableDecimalType), decimalPropertyExpression);


            var stringTypeArray = new[] { typeof(String) };
            var containsMethod = typeof(String).GetMethod("Contains", stringTypeArray); // Contains method
            var valueToBeChecked = Expression.Constant(propertyValue, typeof(String)); // property value as a constant

            var finalContainsExpression = Expression.Call(stringConvertExp, containsMethod, valueToBeChecked); // .Contains(propertyValue)

            return Expression.Lambda<Func<T, bool>>(finalContainsExpression, parameterExpression);
        }

// A public method for passing in the search string
public static Expression<Func<T, bool>> ContainsExpression<T>(string value)
        {
            var properties = typeof(T).GetProperties();
            Expression<Func<T, bool>> finalExpression = PredicateBuilder.False<T>();
            var parameterExpression = Expression.Parameter(typeof(T), typeof(T).Name);
            string propertyName = String.Empty;
            foreach (var property in properties)
            {
                var propertyType = property.PropertyType.Name;

                if (propertyType == "String")
                {
                    var propContainsExpression = ContainsInStringTypeExpression<T>(property.Name, value);
                    finalExpression = finalExpression.Or(propContainsExpression);
                }
                else if (IsNumericType(propertyType))
                {
                    var propContainsExpression = ContainsInNumericTypeExpression<T>(property.Name, value);
                    finalExpression = finalExpression.Or(propContainsExpression);
                }
                else
                {
                    // any type other than numeric types and string are not included in the "search" functionality at the moment
                }
            }

            return finalExpression;
        }

Edit #1: I wonder if what you are really after is a way to encapsulate PropertyChanged Events within an ObservableCollection: so that you could assign one Delegate to the ObservableCollection that would route all PropertyChanged notifications to one EventHandler you defined ? 

public Student(DateTime admissionDate, string stuName = "", string stuClass = "", string stuAddress = "")
{
   AdmissionDate = admissionDate;
   StuName = stuName;
   StuClass = stuClass;
   StuAddress = stuAddress;
}

public class Students : ObservableCollection<Student>
{
    internal void Add(string admDate, string name)
    {
        base.Add(new Student(Convert.ToDateTime(admDate), name));
    }
}

Students StudentsCollection = new Students
{
    {"02/05/2012", "Moe"},
    {"11/05/2013", "Curly"},
    {"02/05/2014", "Larry"},
    {"01/05/2010", "Mutt"},
    {"02/05/2010", "Jeff"},
    {"01/05/2009", "Dagwood"}
};

// somewhere in your initialization code
StudentsCollection.CollectionChanged += StudentsCollection_CollectionChanged;  

private void StudentsCollection_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
    switch (e.Action)
    {
        case NotifyCollectionChangedAction.Add:
            // new item added
            break;
        case NotifyCollectionChangedAction.Remove:
            // item removed
            break;
        // and so on ...
    }
}