FileChunks | C# Online Compiler

FileChunks by woldaker

#nullable enable
using System;
using System.Linq;
using System.Text;
using System.Collections.Generic;

// IFileChunk
public interface IFileChunk
{
    public string? ToHeaderChunk();
    public string ToFileChunk();
}

// FileChunk
public abstract record FileChunk : IFileChunk
{
    public string? Header { get; init; } = null;
    public string? ToHeaderChunk() => Header;

    public virtual string ToFileChunk()
    {
        return QuoteIfNecessary(ToString());
    }

    //public static implicit operator string(FileChunk fc) => fc.ToString();

    // You must override ToString() to be a FileChunk.
    public abstract override string ToString();

    protected static bool NeedsQuotes(string rawValue)
    {
        var needsQuotes = new char[] { ',', '|', '\'', '\"', '\r', '\n' };
        return rawValue.Any(c => needsQuotes.Contains(c));
    }

    protected static string Quote(string rawValue)
    {
        var valueWithExistingQuotesDoubled = rawValue.Replace("\"", "\"\"");
        return string.Format("\"{0}\"", valueWithExistingQuotesDoubled);
    }

    protected static string QuoteIfNecessary(string rawValue)
    {
        return NeedsQuotes(rawValue) ?
            Quote(rawValue) :
            rawValue;
    }
}

// FileChunk<T>
public record FileChunk<T>(
    T? Value = default
) : FileChunk
{
	public FileChunk(T? val, string? header = null)
		: this(val)
	{
		Header = header;
	}
	
    public override string ToString() => Value?.ToString() ?? string.Empty;
}

// StringChunk
public record StringChunk(
    string? Value = default
) : FileChunk<string>(Value)
{
	public StringChunk(string? val, string? header = null)
		: this(val)
	{
		Header = header;
	}
}

// CurrencyChunk
public record CurrencyChunk(
    decimal Value = default
) : FileChunk<decimal>(Value)
{
	public CurrencyChunk(decimal val, string? header = null)
		: this(val)
	{
		Header = header;
	}
    public override string ToString() => $"{Value:0.00}";
}

// ShortAddressChunk
public record ShortAddressChunk(
    StringChunk Line1,
    StringChunk Line2,
    StringChunk Line3,
    StringChunk Country
) : FileChunkGroup(Line1, Line2, Line3, Country);

// LongAddressChunk
public record LongAddressChunk(
    StringChunk Line1,
    StringChunk Line2,
    StringChunk Line3,
    StringChunk City,
    StringChunk State,
    StringChunk Zip,
    StringChunk Country
) : FileChunkGroup(Line1, Line2, Line3, City, State, Zip, Country);

// FileChunkGroup
public record FileChunkGroup : IFileChunk
{
    private char Delim { get; init; } = ',';
    private List<IFileChunk> Chunks { get; init; }
	
    public FileChunkGroup(params IFileChunk[] fileChunks)
		: this(fileChunks.ToList())
    {}
	
    public FileChunkGroup(char delim, params IFileChunk[] fileChunks)
		: this(delim, fileChunks.ToList())
    {}
	
    public FileChunkGroup(IEnumerable<IFileChunk> fileChunks)
    {
        Chunks = fileChunks.ToList();
    }
	
    public FileChunkGroup(char delim, IEnumerable<IFileChunk> fileChunks)
        : this(fileChunks)
    {
        Delim = delim;
    }
	
    public string? ToHeaderChunk()
    {
        var headerChunks = Chunks.Select(fc => fc.ToHeaderChunk());

        // All the file chunks need a header or none of them get one
        if (headerChunks is null
            || !headerChunks.Any()
            || !headerChunks.All(hc => !string.IsNullOrWhiteSpace(hc))
        )
        {
            return null;
        }

        return string.Join(Delim, headerChunks);
    }

    public string ToFileChunk()
    {
        var chunks = Chunks.Select(fc => fc.ToFileChunk());
        return string.Join(Delim, chunks);
    }
}

// FixedSizeFileChunk<TChunk>
public abstract record FixedSizeFileChunk<TChunk> : FileChunk<TChunk>
{
    protected int Size { get; init; }

    public FixedSizeFileChunk(int size)
    {
        if (size < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(size));
        }

        Size = size;
    }

    public override string ToFileChunk()
    {
        if (Size == 0)
        {
            return string.Empty;
        }

        var chunk = ToString().Crop(Size);

        // Account for the 2 characters that the quotes will take up if we need them
        if (NeedsQuotes(chunk))
        {
            if (Size <= 2)
            {
                throw new FormatException($@"
                    Cannot use value '{ToString()}' as type {nameof(FixedSizeFileChunk<TChunk>)} of size {Size}:
                    That value needs quotes but the size limit is too small fit quotes into.
                ");
            }

            chunk = Quote(chunk.Crop(Size - 2));
        }

        return chunk;
    }
}

// WholeFileChunk
public class WholeFileChunk : IFileChunk
{
    private string? Header { get; init; }
    public List<FileChunkGroup> Records { get; init; }

    public WholeFileChunk(List<FileChunkGroup> records)
    {
        Records = records;
        
        Header = records.FirstOrDefault(fcg =>
            !string.IsNullOrWhiteSpace(fcg.ToHeaderChunk())
        )?.ToHeaderChunk();
    }

    public string? ToHeaderChunk() => Header;

    public string ToFileChunk()
    {
        var sb = new StringBuilder();

        var headerChunk = ToHeaderChunk();

        if (!string.IsNullOrWhiteSpace(headerChunk))
        {
            sb.AppendLine(headerChunk);
        }

        foreach (var chunkGroup in Records)
        {
            sb.AppendLine(chunkGroup.ToFileChunk());
        }

        return sb.ToString();
    }
}

// StringExtensions
public static class StringExtensions
{
    public static string Crop(this string input, int length)
    {
    	return (input.Length > length) ? input.Remove(length) : input;
	}
}

// DetailFieldAttribute
[AttributeUsage(AttributeTargets.Property)]
public class DetailFieldAttribute : Attribute
{
    public int Index { get; init; }
	public Type ChunkType { get; init; }
    public string Header { get; init; }

    public DetailFieldAttribute(int index, Type chunkType, string header)
    {
        Index = index;
		ChunkType = chunkType;
        Header = header;
    }
}

// StringFieldAttribute
[AttributeUsage(AttributeTargets.Property)]
public class StringFieldAttribute : DetailFieldAttribute
{
    public StringFieldAttribute(int index, string header)
		: base(index, typeof(StringChunk), header)
    {}
}

// CurrencyFieldAttribute
[AttributeUsage(AttributeTargets.Property)]
public class CurrencyFieldAttribute : DetailFieldAttribute
{
    public CurrencyFieldAttribute(int index, string header)
		: base(index, typeof(CurrencyChunk), header)
    {}
}

// DTO
public record DTO
{
    public Guid PaymentId { get; set; }

    public string RecipientACCTNumber { get; set; }
    public string? RecipientName { get; set; }
    public string? RecipientAddress1 { get; set; }
    public string? RecipientAddress2 { get; set; }
    public string? RecipientAddress3 { get; set; }
    public string? RecipientCountry { get; set; }
	
    public string BeneficiaryName { get; set; }
    public string BeneficiarySWIFT { get; set; }
    public string BeneficiaryIBAN { get; set; }
	
	public decimal Amount { get; set; }
	
    public DTO(
        Guid paymentId,
        string? acct,
        string? name,
        string? addr1,
        string? addr2,
        string? addr3,
        string? country,
        string benName,
        string benSwift,
        string? benIban,
		decimal amount
    )
    {
        PaymentId = paymentId;
        
        RecipientACCTNumber = acct ?? string.Empty;
        RecipientName = name;
        RecipientAddress1 = addr1;
        RecipientAddress2 = addr2;
        RecipientAddress3 = addr3;
        RecipientCountry = country;

        BeneficiaryName = benName;
		BeneficiarySWIFT = benSwift ?? string.Empty;
		BeneficiaryIBAN = benIban ?? string.Empty;
		
		Amount = amount;
    }
}

// Detail
public class Detail
{
    [StringField(0, "recipient_account")]
    public string RecipientACCTNumber { get; set; }

    [StringField(1, "recipient_name")]
    public string? RecipientName { get; set; }

    [StringField(2, "recipient_addr_1")]
    public string? RecipientAddress1 { get; set; }

    [StringField(3, "recipient_addr_2")]
    public string? RecipientAddress2 { get; set; }

    [StringField(4, "recipient_addr_3")]
    public string? RecipientAddress3 { get; set; }

    [StringField(5, "recipient_country")]
    public string? RecipientCountry { get; set; }

    [StringField(6, "beneficiary_name")]
    public string BeneficiaryName { get; set; }

    [StringField(7, "beneficiary_swift_bic")]
    public string BeneficiarySWIFT { get; set; }

    [StringField(8, "beneficiary_iban")]
    public string BeneficiaryIBAN { get; set; }
	
	[CurrencyField(9, "amount")]
	public decimal Amount { get; set; }

    public Guid PaymentId { get; set; }

    public Detail(DTO dto)
    {
        PaymentId = dto.PaymentId;
        
        RecipientACCTNumber = dto.RecipientACCTNumber;
        RecipientName = dto.RecipientName;
        RecipientAddress1 = dto.RecipientAddress1;
        RecipientAddress2 = dto.RecipientAddress2;
        RecipientAddress3 = dto.RecipientAddress3;
        RecipientCountry = dto.RecipientCountry;

        BeneficiaryName = dto.BeneficiaryName;
		BeneficiarySWIFT = dto.BeneficiarySWIFT;
		BeneficiaryIBAN = dto.BeneficiaryIBAN;
		
		Amount = dto.Amount;
		
		var providesAcct = !string.IsNullOrWhiteSpace(dto.RecipientACCTNumber);
		var providesIban = !string.IsNullOrWhiteSpace(dto.BeneficiaryIBAN);
		
		if (!(providesAcct ^ providesIban))
		{
			throw new InvalidOperationException(
				"Must provide either an acct or benIban but not both."
			);
		}
		
		if (string.IsNullOrWhiteSpace(dto.BeneficiarySWIFT))
		{
			throw new InvalidOperationException(
				"Must provide a swift number."
			);
		}
    }
    
    public FileChunkGroup ToFileChunkGroup()
    {
		var chunks = new List<IFileChunk>();
		
        var grp = (
            from p in GetType().GetProperties()
            let attr = p.GetCustomAttributes(typeof(DetailFieldAttribute), false).First() as DetailFieldAttribute
            orderby attr.Index
            select new {
				Attr = attr,
				Prop = p
			}
        ).ToList();

		foreach (var g in grp)
		{
			var chunk = (IFileChunk)Activator.CreateInstance(g.Attr.ChunkType, g.Prop.GetValue(this), g.Attr.Header)!;
			chunks.Add(chunk);
		}
		
        return new FileChunkGroup(chunks);
    }
}

public class FileContainer
{
    public List<Detail> Details { get; init; }

    public FileContainer(List<DTO> details)
    {
        Details = details.Select(detail => new Detail(detail)).ToList();
    }

    public string CreateFile()
    {
        var file = new WholeFileChunk(Details.Select(d => d.ToFileChunkGroup()).ToList());
        return file.ToFileChunk();
    }
}

// Program
public class Program
{
	public static void Main()
	{
		var dtos = new List<DTO>()
		{
			new DTO(
				paymentId: Guid.NewGuid(),
				acct: "12345678",
				name: "John",
				addr1: "123 Main St.",
				addr2: "#456",
				addr3: null,
				country: "US",
				benName: "Sam",
				benSwift: "87654321",
				benIban: null,
				amount: 99m
			),
			new DTO(
				paymentId: Guid.NewGuid(),
				acct: "12345678",
				name: "John",
				addr1: "123 Main St.",
				addr2: "#456",
				addr3: null,
				country: "US",
				benName: "Sam",
				benSwift: "87654321",
				benIban: null,
				amount: 12.34m
			)
		};
		
		var file = new FileContainer(dtos);
		Console.WriteLine(file.CreateFile());
	}
}

​x
 
#nullable enable
using System;
using System.Linq;
using System.Text;
using System.Collections.Generic;
​
// IFileChunk
public interface IFileChunk
{
    public string? ToHeaderChunk();
    public string ToFileChunk();
}
​
// FileChunk
public abstract record FileChunk : IFileChunk
{
    public string? Header { get; init; } = null;
    public string? ToHeaderChunk() => Header;
​
    public virtual string ToFileChunk()
    {
        return QuoteIfNecessary(ToString());
    }
​
    //public static implicit operator string(FileChunk fc) => fc.ToString();
​
    // You must override ToString() to be a FileChunk.
    public abstract override string ToString();
​
    protected static bool NeedsQuotes(string rawValue)
    {
        var needsQuotes = new char[] { ',', '|', '\'', '\"', '\r', '\n' };
        return rawValue.Any(c => needsQuotes.Contains(c));
    }
​
    protected static string Quote(string rawValue)
    {
        var valueWithExistingQuotesDoubled = rawValue.Replace("\"", "\"\"");
        return string.Format("\"{0}\"", valueWithExistingQuotesDoubled);
    }
​
    protected static string QuoteIfNecessary(string rawValue)
    {
        return NeedsQuotes(rawValue) ?
            Quote(rawValue) :
            rawValue;
    }
}
​
// FileChunk<T>
public record FileChunk<T>(
    T? Value = default
) : FileChunk
{
    public FileChunk(T? val, string? header = null)
        : this(val)
    {
        Header = header;
    }
    
    public override string ToString() => Value?.ToString() ?? string.Empty;
}
​
// StringChunk
public record StringChunk(
    string? Value = default
) : FileChunk<string>(Value)
{
    public StringChunk(string? val, string? header = null)
        : this(val)
    {
        Header = header;
    }
}
​
// CurrencyChunk
public record CurrencyChunk(
    decimal Value = default
) : FileChunk<decimal>(Value)
{
    public CurrencyChunk(decimal val, string? header = null)
        : this(val)
    {
        Header = header;
    }
    public override string ToString() => $"{Value:0.00}";
}
​
// ShortAddressChunk
public record ShortAddressChunk(
    StringChunk Line1,
    StringChunk Line2,
    StringChunk Line3,
    StringChunk Country
) : FileChunkGroup(Line1, Line2, Line3, Country);
​
// LongAddressChunk
public record LongAddressChunk(
    StringChunk Line1,
    StringChunk Line2,
    StringChunk Line3,
    StringChunk City,
    StringChunk State,
    StringChunk Zip,
    StringChunk Country
) : FileChunkGroup(Line1, Line2, Line3, City, State, Zip, Country);
​
// FileChunkGroup
public record FileChunkGroup : IFileChunk
{
    private char Delim { get; init; } = ',';
    private List<IFileChunk> Chunks { get; init; }
    
    public FileChunkGroup(params IFileChunk[] fileChunks)
        : this(fileChunks.ToList())
    {}
    
    public FileChunkGroup(char delim, params IFileChunk[] fileChunks)
        : this(delim, fileChunks.ToList())
    {}
    
    public FileChunkGroup(IEnumerable<IFileChunk> fileChunks)
    {
        Chunks = fileChunks.ToList();
    }
    
    public FileChunkGroup(char delim, IEnumerable<IFileChunk> fileChunks)
        : this(fileChunks)
    {
        Delim = delim;
    }
    
    public string? ToHeaderChunk()
    {
        var headerChunks = Chunks.Select(fc => fc.ToHeaderChunk());
​
        // All the file chunks need a header or none of them get one
        if (headerChunks is null
            || !headerChunks.Any()
            || !headerChunks.All(hc => !string.IsNullOrWhiteSpace(hc))
        )
        {
            return null;
        }
​
        return string.Join(Delim, headerChunks);
    }
​
    public string ToFileChunk()
    {
        var chunks = Chunks.Select(fc => fc.ToFileChunk());
        return string.Join(Delim, chunks);
    }
}
​
// FixedSizeFileChunk<TChunk>
public abstract record FixedSizeFileChunk<TChunk> : FileChunk<TChunk>
{
    protected int Size { get; init; }
​
    public FixedSizeFileChunk(int size)
    {
        if (size < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(size));
        }
​
        Size = size;
    }
​
    public override string ToFileChunk()
    {
        if (Size == 0)
        {
            return string.Empty;
        }
​
        var chunk = ToString().Crop(Size);
​
        // Account for the 2 characters that the quotes will take up if we need them
        if (NeedsQuotes(chunk))
        {
            if (Size <= 2)
            {
                throw new FormatException($@"
                    Cannot use value '{ToString()}' as type {nameof(FixedSizeFileChunk<TChunk>)} of size {Size}:
                    That value needs quotes but the size limit is too small fit quotes into.
                ");
            }
​
            chunk = Quote(chunk.Crop(Size - 2));
        }
​
        return chunk;
    }
}
​
// WholeFileChunk
public class WholeFileChunk : IFileChunk
{
    private string? Header { get; init; }
    public List<FileChunkGroup> Records { get; init; }
​
    public WholeFileChunk(List<FileChunkGroup> records)
    {
        Records = records;
        
        Header = records.FirstOrDefault(fcg =>
            !string.IsNullOrWhiteSpace(fcg.ToHeaderChunk())
        )?.ToHeaderChunk();
    }
​
    public string? ToHeaderChunk() => Header;
​
    public string ToFileChunk()
    {
        var sb = new StringBuilder();
​
        var headerChunk = ToHeaderChunk();
​
        if (!string.IsNullOrWhiteSpace(headerChunk))
        {
            sb.AppendLine(headerChunk);
        }
​
        foreach (var chunkGroup in Records)
        {
            sb.AppendLine(chunkGroup.ToFileChunk());
        }
​
        return sb.ToString();
    }
}
​
// StringExtensions
public static class StringExtensions
{
    public static string Crop(this string input, int length)
    {
        return (input.Length > length) ? input.Remove(length) : input;
    }
}
​
// DetailFieldAttribute
[AttributeUsage(AttributeTargets.Property)]
public class DetailFieldAttribute : Attribute
{
    public int Index { get; init; }
    public Type ChunkType { get; init; }
    public string Header { get; init; }
​
    public DetailFieldAttribute(int index, Type chunkType, string header)
    {
        Index = index;
        ChunkType = chunkType;
        Header = header;
    }
}
​
// StringFieldAttribute
[AttributeUsage(AttributeTargets.Property)]
public class StringFieldAttribute : DetailFieldAttribute
{
    public StringFieldAttribute(int index, string header)
        : base(index, typeof(StringChunk), header)
    {}
}
​
// CurrencyFieldAttribute
[AttributeUsage(AttributeTargets.Property)]
public class CurrencyFieldAttribute : DetailFieldAttribute
{
    public CurrencyFieldAttribute(int index, string header)
        : base(index, typeof(CurrencyChunk), header)
    {}
}
​
// DTO
public record DTO
{
    public Guid PaymentId { get; set; }
​
    public string RecipientACCTNumber { get; set; }
    public string? RecipientName { get; set; }
    public string? RecipientAddress1 { get; set; }
    public string? RecipientAddress2 { get; set; }
    public string? RecipientAddress3 { get; set; }
    public string? RecipientCountry { get; set; }
    
    public string BeneficiaryName { get; set; }
    public string BeneficiarySWIFT { get; set; }
    public string BeneficiaryIBAN { get; set; }
    
    public decimal Amount { get; set; }
    
    public DTO(
        Guid paymentId,
        string? acct,
        string? name,
        string? addr1,
        string? addr2,
        string? addr3,
        string? country,
        string benName,
        string benSwift,
        string? benIban,
        decimal amount
    )
    {
        PaymentId = paymentId;
        
        RecipientACCTNumber = acct ?? string.Empty;
        RecipientName = name;
        RecipientAddress1 = addr1;
        RecipientAddress2 = addr2;
        RecipientAddress3 = addr3;
        RecipientCountry = country;
​
        BeneficiaryName = benName;
        BeneficiarySWIFT = benSwift ?? string.Empty;
        BeneficiaryIBAN = benIban ?? string.Empty;
        
        Amount = amount;
    }
}
​
// Detail
public class Detail
{
    [StringField(0, "recipient_account")]
    public string RecipientACCTNumber { get; set; }
​
    [StringField(1, "recipient_name")]
    public string? RecipientName { get; set; }
​
    [StringField(2, "recipient_addr_1")]
    public string? RecipientAddress1 { get; set; }
​
    [StringField(3, "recipient_addr_2")]
    public string? RecipientAddress2 { get; set; }
​
    [StringField(4, "recipient_addr_3")]
    public string? RecipientAddress3 { get; set; }
​
    [StringField(5, "recipient_country")]
    public string? RecipientCountry { get; set; }
​
    [StringField(6, "beneficiary_name")]
    public string BeneficiaryName { get; set; }
​
    [StringField(7, "beneficiary_swift_bic")]
    public string BeneficiarySWIFT { get; set; }
​
    [StringField(8, "beneficiary_iban")]
    public string BeneficiaryIBAN { get; set; }
    
    [CurrencyField(9, "amount")]
    public decimal Amount { get; set; }
​
    public Guid PaymentId { get; set; }
​
    public Detail(DTO dto)
    {
        PaymentId = dto.PaymentId;
        
        RecipientACCTNumber = dto.RecipientACCTNumber;
        RecipientName = dto.RecipientName;
        RecipientAddress1 = dto.RecipientAddress1;
        RecipientAddress2 = dto.RecipientAddress2;
        RecipientAddress3 = dto.RecipientAddress3;
        RecipientCountry = dto.RecipientCountry;
​
        BeneficiaryName = dto.BeneficiaryName;
        BeneficiarySWIFT = dto.BeneficiarySWIFT;
        BeneficiaryIBAN = dto.BeneficiaryIBAN;
        
        Amount = dto.Amount;
        
        var providesAcct = !string.IsNullOrWhiteSpace(dto.RecipientACCTNumber);
        var providesIban = !string.IsNullOrWhiteSpace(dto.BeneficiaryIBAN);
        
        if (!(providesAcct ^ providesIban))
        {
            throw new InvalidOperationException(
                "Must provide either an acct or benIban but not both."
            );
        }
        
        if (string.IsNullOrWhiteSpace(dto.BeneficiarySWIFT))
        {
            throw new InvalidOperationException(
                "Must provide a swift number."
            );
        }
    }
    
    public FileChunkGroup ToFileChunkGroup()
    {
        var chunks = new List<IFileChunk>();
        
        var grp = (
            from p in GetType().GetProperties()
            let attr = p.GetCustomAttributes(typeof(DetailFieldAttribute), false).First() as DetailFieldAttribute
            orderby attr.Index
            select new {
                Attr = attr,
                Prop = p
            }
        ).ToList();
​
        foreach (var g in grp)
        {
            var chunk = (IFileChunk)Activator.CreateInstance(g.Attr.ChunkType, g.Prop.GetValue(this), g.Attr.Header)!;
            chunks.Add(chunk);
        }
        
        return new FileChunkGroup(chunks);
    }
}
​
public class FileContainer
{
    public List<Detail> Details { get; init; }
​
    public FileContainer(List<DTO> details)
    {
        Details = details.Select(detail => new Detail(detail)).ToList();
    }
​
    public string CreateFile()
    {
        var file = new WholeFileChunk(Details.Select(d => d.ToFileChunkGroup()).ToList());
        return file.ToFileChunk();
    }
}
​
// Program
public class Program
{
    public static void Main()
    {
        var dtos = new List<DTO>()
        {
            new DTO(
                paymentId: Guid.NewGuid(),
                acct: "12345678",
                name: "John",
                addr1: "123 Main St.",
                addr2: "#456",
                addr3: null,
                country: "US",
                benName: "Sam",
                benSwift: "87654321",
                benIban: null,
                amount: 99m
            ),
            new DTO(
                paymentId: Guid.NewGuid(),
                acct: "12345678",
                name: "John",
                addr1: "123 Main St.",
                addr2: "#456",
                addr3: null,
                country: "US",
                benName: "Sam",
                benSwift: "87654321",
                benIban: null,
                amount: 12.34m
            )
        };
        
        var file = new FileContainer(dtos);
        Console.WriteLine(file.CreateFile());
    }
}

----------------------------
---------PERIMETRO----------
----------------------------
Ingrese el valor del area de un cuadrado en cm

Last Run:	12:53:42 am
Compile:	0.12s
Execute:	0.006s
Memory:	32kb
CPU:	0s

View IL Code