Hente informationer ind i en metode

Du kan lave en klasse som indeholder information om hver enhed med afgift på. Den kan ekempeltvis hedde Enhed.

public class Enhed
{
    //Afgiften på enheden.
    public double Afgift { get; set; }

    //Navnet på enheden.
    public string Navn { get; set; }

    //Typen af enheden. F.eks. "Bil" eller "Eftermonteret udstyr". Kan eventuelt laves om til en enumerator.
    public string Type { get; set; }
}


I din metode kan du tage et array af Enhed instanser ind som parameter

public void MinMetode(Enhed[] enheder)
{
  //kode.
}

For at finde ud af hvad som er hvad i metoden, kan du gøre noget ala:


public void MinMetode(Enhed[] enheder)
{
    foreach (Enhed enhed in enheder)
    {
        switch (enhed.Type)
        {
            case "Bil":
                //Skriv noget kode for biler.
                break;
            case "Fabriksmonteret udstyr":
                //Skriv noget kode for fabriksmonteret udstyr.
                break;
            case "Eftermonteret udstyr":
                //Skriv noget kode for eftermonteret udstyr.
                break;
            default:
                //Udstyret er af en ukendt type, så der kastes en fejl.
                throw new Exception("Ukendt enhedstype");
        }
    }
}

Hej aaberg cc,

Tak for dit svar.... jeg har aldrig forstået det med arrays, så undgår dem helst. Jeg har valgt at forlange en (flere) datatable(s) som input istedet.

Smid et svar og du får points :-)

mvh
simsen :-)

svar :-)

Det her er så et eksempel på kode, hvor man kan vælge forskellige måder at
lave det på.

Jeg vil poste 3 forskellige versioner af samme kode.

using System;

namespace E
{
    public class Unit
    {
        public string Name { get; set; }
        public string UnitType { get; set; }
        public double Tax { get; set; }
        public Unit(string name, string unittype, double tax)
        {
            this.Name = name;
            this.UnitType = unittype;
            this.Tax = tax;
        }
    }
    public class Program
    {
        public static double TotalTax(Unit[] ua)
        {
            double sum = 0;
            foreach(Unit u in ua)
            {
                sum += u.Tax;
            }
            return sum;
        }
        public static int NumberOfFactoryInstalled(Unit[] ua)
        {
            int sum = 0;
            foreach(Unit u in ua)
            {
                switch(u.UnitType)
                {
                    case "Bil":
                    case "Eftersmonteret udstyr":
                        // nothing
                        break;
                    case "Fabriksmonteret udstyr":
                        sum++;
                        break;
                    default:
                        throw new ArgumentException("Not a valid unit type");
                }
            }
            return sum;
        }
        public static void Main(string[] args)
        {
            Unit[] ua = new Unit[4];
            ua[0] = new Unit("Folkevogn", "Bil", 240.00);
            ua[1] = new Unit("Udstyr #1", "Fabriksmonteret udstyr", 10.00);
            ua[2] = new Unit("Udstyr #2", "Fabriksmonteret udstyr", 50.00);
            ua[3] = new Unit("Udstyr #3", "Eftersmonteret udstyr", 200.00);
            Console.WriteLine(TotalTax(ua));
            Console.WriteLine(NumberOfFactoryInstalled(ua));
            Console.ReadKey();
        }
    }
}

// 1. use an enum instead of a string for unit type
// 2. use collection instead of array
// 3. use decimal instead of double for tax amount
// 4. specify the wrong unit type in exception

using System;
using System.Collections.Generic;

namespace E
{
    public enum TypesOfUnit
    {
        Car,
        FactoryInstalled,
        AfterMarketInstalled
    }
    public class Unit
    {
        public string Name { get; set; }
        public TypesOfUnit UnitType { get; set; }
        public decimal Tax { get; set; }
        public Unit(string name, TypesOfUnit unittype, decimal tax)
        {
            this.Name = name;
            this.UnitType = unittype;
            this.Tax = tax;
        }
    }
    public class Program
    {
        public static decimal TotalTax(List<Unit> ulst)
        {
            decimal sum = 0;
            foreach(Unit u in ulst)
            {
                sum += u.Tax;
            }
            return sum;
        }
        public static int NumberOfFactoryInstalled(List<Unit> ulst)
        {
            int sum = 0;
            foreach(Unit u in ulst)
            {
                switch(u.UnitType)
                {
                    case TypesOfUnit.Car:
                    case TypesOfUnit.AfterMarketInstalled:
                        // nothing
                        break;
                    case TypesOfUnit.FactoryInstalled:
                        sum++;
                        break;
                    default:
                        throw new ArgumentException("Not a valid unit type: " + (int)u.UnitType);
                }
            }
            return sum;
        }
        public static void Main(string[] args)
        {
            List<Unit> ulst = new List<Unit>();
            ulst.Add(new Unit("Folkevogn", TypesOfUnit.Car, 240.00m));
            ulst.Add(new Unit("Udstyr #1", TypesOfUnit.FactoryInstalled, 10.00m));
            ulst.Add(new Unit("Udstyr #2", TypesOfUnit.FactoryInstalled, 50.00m));
            ulst.Add(new Unit("Udstyr #3", TypesOfUnit.AfterMarketInstalled, 200.00m));
            Console.WriteLine(TotalTax(ulst));
            Console.WriteLine(NumberOfFactoryInstalled(ulst));
            Console.ReadKey();
        }
    }
}

// 5. use polymorphism

using System;
using System.Collections.Generic;

namespace E
{
    public enum TypesOfUnit
    {
        Car,
        FactoryInstalled,
        AfterMarketInstalled
    }
    public abstract class Unit
    {
        private TypesOfUnit unittype;
        public string Name { get; set; }
        public TypesOfUnit UnitType { get { return unittype; } }
        public decimal Tax { get; set; }
        public abstract bool IsFactoryInstalled { get; }
        public Unit(string name, TypesOfUnit unittype, decimal tax)
        {
            this.Name = name;
            this.unittype = unittype;
            this.Tax = tax;
        }
    }
    public class CarUnit : Unit
    {
        public CarUnit(string name, decimal tax) : base(name, TypesOfUnit.Car, tax)
        {
        }
        public override bool IsFactoryInstalled { get { return false; } }
    }
    public class FactoryInstalledUnit : Unit
    {
        public FactoryInstalledUnit(string name, decimal tax) : base(name, TypesOfUnit.FactoryInstalled, tax)
        {
        }
        public override bool IsFactoryInstalled { get { return true; } }
    }
    public class AfterMarketInstalledUnit : Unit
    {
        public AfterMarketInstalledUnit(string name, decimal tax) : base(name, TypesOfUnit.AfterMarketInstalled, tax)
        {
        }
        public override bool IsFactoryInstalled { get { return false; } }
    }
    public class Program
    {
        public static decimal TotalTax(List<Unit> ulst)
        {
            decimal sum = 0;
            foreach(Unit u in ulst)
            {
                sum += u.Tax;
            }
            return sum;
        }
        public static int NumberOfFactoryInstalled(List<Unit> ulst)
        {
            int sum = 0;
            foreach(Unit u in ulst)
            {
                if(u.IsFactoryInstalled)
                {
                    sum++;
                }
            }
            return sum;
        }
        public static void Main(string[] args)
        {
            List<Unit> ulst = new List<Unit>();
            ulst.Add(new CarUnit("Folkevogn", 240.00m));
            ulst.Add(new FactoryInstalledUnit("Udstyr #1", 10.00m));
            ulst.Add(new FactoryInstalledUnit("Udstyr #2", 50.00m));
            ulst.Add(new AfterMarketInstalledUnit("Udstyr #3", 200.00m));
            Console.WriteLine(TotalTax(ulst));
            Console.WriteLine(NumberOfFactoryInstalled(ulst));
            Console.ReadKey();
        }
    }
}

Eksemplerne er console app ikke web app, men det har ikke nogen betydning for pointen.