C#

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 ...
    }
}

"2. Be specific! Don't ask "can someone send me the code to create an application that does 'X'. Pinpoint exactly what it is you need help with."