C#

crystalReportViewer1.ReportSource = c2;

c2.PrintToPrinter(1, true, 0, 0)

c2.SetDatabaseLogon("sa", "789654");

RobF_83 wrote:

is the line that actually loads the report into the report control.
You need to replace that with this:

c2.PrintToPrinter(1, true, 0, 0)

You should also place it AFTER

c2.SetDatabaseLogon("sa", "789654");

void report()
       {
           cnx = new SqlConnection(db.RXcon);
          try
           {
               cnx.Open();
        string cg=" SELECT * from Consultation where NumFact=" + @Convert.ToInt32(textBox4.Text);
               commd2 = new SqlCommand(cg);
               commd2.Connection = cnx;
               DataSet dts = new DataSet();
               DataTable dt = new DataTable();
               dtr = commd2.ExecuteReader();
               dt.Load(dtr);
               FactCons c2 = new FactCons();
               c2.SetDataSource(dt);
               crystalReportViewer1.ReportSource = c2;
               c2.SetDatabaseLogon("sa", "765432");
               c2.PrintToPrinter(1, true,0, 0);// i just add this and it works correctly

           }
           catch (Exception ex)
           {
              MessageBox.Show(ex.Message);
           }
           cnx.Close();
       }

result = (a + n*b) % b

double bearing4 = (-1.779406909 + 2 * Math.PI) % Math.PI;

Jassim Rahma wrote:

which is different that Excel

private double Mod(double a, double b)
    {
    return a - b * Math.Floor(a / b);
    }

using System;
using System.Runtime.InteropServices.WindowsRuntime;

namespace Utilities
{
    public static class MathExtensions
    {
        // ideas from: Lippert, Gravell, Skeet
        public static double ModT<T>(this T i1, T i2)
        {
            double v1 = i1.GetDouble();
            double v2 = i2.GetDouble();
            return v1 - v2 * Math.Floor(v1 / v2);
        }

        public static double ModT1T2<T1, T2>(this T1 i1, T2 i2)
        {
            double v1 = i1.GetDouble();
            double v2 = i2.GetDouble();
            return v1 - v2 * Math.Floor(v1 / v2);
        }

        public static double GetDouble<T>(this T i1)
        {
            double v1;

            try
            {
                v1 = Convert.ToDouble(i1);
            }
            catch (InvalidCastException iex)
            {
                throw new InvalidCastException($"type {typeof(T)} cannot be cast to double: {iex.Message}");
            }

            catch (FormatException fex)
            {
                throw new FormatException($"type {typeof(T)} cannot be used: {fex.Message}");
            }

            catch (OverflowException oex)
            {
                throw new OverflowException($"type {typeof(T)} result is an overflow: {oex.Message}");
            }

            return v1;
        }
    }
}

double dbl = -1.779406909.ModT(2 * Math.PI);

double int1 = 221.ModT(20);

double sngl = 102.0f.ModT(20.0f);

double deci = 102.0m.ModT(20.0m);

double intdecicombo = 100.0.ModT1T2(34.56m);

double dbl2 = 100.0.ModT(34.56);

BillWoodruff wrote:

C#

catch (InvalidCastException iex)
{
    throw new InvalidCastException($"type {typeof(T)} cannot be cast to double: {iex.Message}");
}

catch (InvalidCastException iex)
{
    throw new InvalidCastException($"Type {typeof(T)} cannot be cast to double: {iex.Message}", iex);
}
catch (FormatException fex)
{
    throw new FormatException($"Value '{i1}' of type {typeof(T)} cannot be converted to a double: {fex.Message}", fex);
}
catch (OverflowException oex)
{
    throw new OverflowException($"Value '{i1}' of type {typeof(T)} is too large for a double: {oex.Message}", oex);
}

public static double ModT<T>(this T i1, T i2) where T : IConvertible { ... }
public static double ModT1T2<T1, T2>(this T1 i1, T2 i2) where T1 : IConvertible where T2 : IConvertible { ... }
public static double GetDouble<T>(this T i1) where T : IConvertible { ... }

where T:
     struct,
     IComparable,
     IComparable<T>,
     IConvertible,
     IEquatable<T>,
     IFormattable

char c = '*';
double a = (double)c; // Works
double b = Convert.ToDouble(c); // Throws

using System.Linq.Expressions;

public static class GenericOperators<T>
{
    public static readonly Func<T, T, T> Add = Create(Expression.Add);
    public static readonly Func<T, T, T> Subtract = Create(Expression.Subtract);
    public static readonly Func<T, T, T> Multiply = Create(Expression.Multiply);
    public static readonly Func<T, T, T> Divide = Create(Expression.Divide);
    
    private static Func<T, T, T> Create(Func<Expression, Expression, BinaryExpression> body)
    {
        try
        {
            Type typeT = typeof(T);
            var left = Expression.Parameter(typeT, "left");
            var right = Expression.Parameter(typeT, "right");

            if (typeT.IsEnum)
            {
                Type enumType = Enum.GetUnderlyingType(typeT);
                var x = Expression.Convert(left, enumType);
                var y = Expression.Convert(right, enumType);

                Expression op = body(x, y);
                if (op.Type == enumType) op = Expression.Convert(op, typeT);

                return Expression.Lambda<Func<T, T, T>>(op, left, right).Compile();
            }

            return Expression.Lambda<Func<T, T, T>>(body(left, right), left, right).Compile();
        }
        catch (InvalidOperationException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
        catch (ArgumentException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
    }
}