コード例 #1
0
        public static Dictionary <string, string> ReturnMatchedIPRange(List <string> ips, List <Value> azureIps)
        {
            Dictionary <string, string> matchedIps = new Dictionary <string, string>();

            foreach (var ip in ips)
            {
                bool      ipFound               = false;
                IPNetwork incomingNetwork       = null;
                IPAddress incomingIp            = IsValidIP(ip) ? IPAddress.Parse(ip) : null;
                bool      incomingNetworkParsed = incomingIp == null?IPNetwork.TryParse(ip, out incomingNetwork) : false;

                if (incomingIp != null || incomingNetwork != null)
                {
                    foreach (var azureip in azureIps)
                    {
                        foreach (var subnet in azureip.properties.addressPrefixes)
                        {
                            IPNetwork network = IPNetwork.Parse(subnet);


                            if (((incomingIp != null && network.Contains(incomingIp)) ||
                                 (incomingNetwork != null && network.Contains(incomingNetwork))) &&
                                !ipFound)
                            {
                                matchedIps.Add(ip, $"{subnet} - {azureip.name}");
                                ipFound = true;
                                break;
                            }
                        }
                    }

                    if (!ipFound)
                    {
                        if (!matchedIps.ContainsKey(ip))
                        {
                            matchedIps.Add(ip, "No Match");
                        }
                    }
                }
                else
                {
                    if (!matchedIps.ContainsKey(ip))
                    {
                        matchedIps.Add(ip, "No Match");
                    }
                }
            }


            return(matchedIps);
        }
コード例 #2
0
        public bool AddSrcAddress(IPAddress SrcIP)
        {
            IPNetwork localnet192 = IPNetwork.Parse("192.168.0.0/16");
            IPNetwork localnet172 = IPNetwork.Parse("172.16.0.0/12");
            IPNetwork localnet169 = IPNetwork.Parse("169.254.0.0/16");
            IPNetwork localnet10  = IPNetwork.Parse("10.0.0.0/8");

            if (SrcIP.IsIPv6LinkLocal || SrcIP.IsIPv6Multicast || SrcIP.IsIPv6SiteLocal || SrcIP.IsIPv6Teredo)
            {
                return(false);
            }
            if (localnet192.Contains(SrcIP) || localnet172.Contains(SrcIP) || localnet169.Contains(SrcIP) || localnet10.Contains(SrcIP))
            {
                return(false);
            }

            if (SrcIP.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
            {
                IPv4SrcList.Add(SrcIP);
            }
            if (SrcIP.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
            {
                IPv6SrcList.Add(SrcIP);
            }
            return(true);
        }
コード例 #3
0
 /// <summary>
 /// Finds the first network interface that has a matching unicast address-
 /// </summary>
 /// <param name="mask">IPv4/IPv6 address or CIDR mask.</param>
 /// <returns>a matching interface or null</returns>
 public static NetworkInterface GetNetworkInterfaceFromCIDR(string mask)
 {
     if (mask.Contains('/'))
     {
         IPNetwork ipnetwork = IPNetwork.Parse(mask);
         foreach (NetworkInterface nic in GetNetworkInterfaces())
         {
             var unicastAddresses = nic.GetIPProperties().UnicastAddresses;
             if (unicastAddresses.Any(ua => ipnetwork.Contains(ua.Address)))
             {
                 return(nic);
             }
         }
     }
     else
     {
         var address = IPAddress.Parse(mask);
         foreach (NetworkInterface nic in GetNetworkInterfaces())
         {
             var unicastAddresses = nic.GetIPProperties().UnicastAddresses;
             if (unicastAddresses.Select(ua => ua.Address).Contains(address))
             {
                 return(nic);
             }
         }
     }
     return(null);
 }
コード例 #4
0
ファイル: Program.cs プロジェクト: sakib1361/IPTest
        static List <IPNetwork> RecursiveAdd(IPNetwork target, IPNetwork subtract, List <IPNetwork> newNetwork)
        {
            if (subtract.Contains(target) || target.Cidr >= 31)
            {
                return(newNetwork);
            }
            var splitted      = Split(target);
            var firstOverLap  = subtract.Overlap(splitted[0]);
            var secondOverlap = subtract.Overlap(splitted[1]);

            if (firstOverLap && secondOverlap)
            {
                RecursiveAdd(splitted[0], subtract, newNetwork);
                RecursiveAdd(splitted[1], subtract, newNetwork);
            }
            else if (firstOverLap)
            {
                newNetwork.Add(splitted[1]);
                RecursiveAdd(splitted[0], subtract, newNetwork);
            }
            else if (secondOverlap)
            {
                newNetwork.Add(splitted[0]);
                RecursiveAdd(splitted[1], subtract, newNetwork);
            }

            return(newNetwork);
        }
コード例 #5
0
ファイル: Program.cs プロジェクト: gvmikhailov/NET
        public static string ReturnNetwork(string ip)
        {
            try
            {
                IPAddress incomingIp = IPAddress.Parse(ip);
                foreach (var subnet in networks)
                {
                    IPNetwork network = IPNetwork.Parse(subnet);

                    if (network.Contains(incomingIp))
                    {
                        return(ip);
                    }
                    else
                    {
                        continue;
                    }
                }
            }
            catch (Exception ex)
            {
                using (StreamWriter writer = new StreamWriter(log, true))
                {
                    while (ex != null)
                    {
                        writer.WriteLine("Message : " + ex.Message + "ip address: " + ip);
                        ex = ex.InnerException;
                    }
                }
            }
            return(string.Empty);
        }
コード例 #6
0
        private async Task FindVnetAndSubnetAsync(CancellationToken cancellationToken)
        {
            Debug.Assert(subscriptionId != null);
            Debug.Assert(resourceGroupName != null);
            Debug.Assert(targetIPAddress != null);

            IPAddress virtualMachineIPAddress;

            if (!IPAddress.TryParse(targetIPAddress, out virtualMachineIPAddress))
            {
                throw new ArgumentException("Invalid format of the IP address");
            }

            var virtualNetworks = (await resourceManager.GetAsync($"/subscriptions/{subscriptionId}/" +
                                                                  $"resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualnetworks",
                                                                  cancellationToken))["value"].ToArray();

            foreach (var virtualNetwork in virtualNetworks)
            {
                var subnets = virtualNetwork["properties"]["subnets"].ToArray();
                foreach (var subnet in subnets)
                {
                    var addressSpace = subnet["properties"].Value <string>("addressPrefix");
                    var ipNetwork    = IPNetwork.Parse(addressSpace);
                    if (IPNetwork.Contains(ipNetwork, virtualMachineIPAddress))
                    {
                        virtualNetworkId = virtualNetwork.Value <string>("id");
                        subnetId         = subnet.Value <string>("id");
                        return;
                    }
                }
            }
            throw new ArgumentException("There is no subnet that contains an IP address " +
                                        $"'{virtualMachineIPAddress}' in a resource group '{resourceGroupName}'");
        }
コード例 #7
0
        private void StartIpBlur(FocusEventArgs e)
        {
            if (!IPAddress.TryParse(subnet.StartIP, out IPAddress ipAddress))
            {
                startIpError = true;
                errorMessage = "The start ip is not valid.";
                return;
            }

            // RFC1918
            IPNetwork network1 = IPNetwork.Parse("10.0.0.0/8");
            IPNetwork network2 = IPNetwork.Parse("172.16.0.0/12");
            IPNetwork network3 = IPNetwork.Parse("192.168.0.0/16");

            if (!network1.Contains(ipAddress) && !network2.Contains(ipAddress) && !network3.Contains(ipAddress))
            {
                startIpError = true;
                errorMessage = "The start ip is not in the range of RFC1918.";
                return;
            }

            subnet.IPRangeId = GetIpRangeId(IPNetwork.Parse($"{subnet.StartIP}/32"));
            if (subnet.IPRangeId < 0)
            {
                startIpError = true;
                errorMessage = "The start ip is not contained in the virtual network's address spaces.";
                return;
            }

            startIpError = false;
            errorMessage = string.Empty;
        }
コード例 #8
0
        private bool IsValidIP(string ip)
        {
            string[] ranges = new string[] {
                "167.220.0.0/16", //Boston
                "131.107.0.0/16", // MS Corp-8 (Redmond)
                "157.54.0.0/15",  // Other MSCorp. ** this list came from Steve Morin.
                "157.56.0.0/15",
                "157.58.0.0/15",
                "157.60.0.0/16",
                //"0.0.0.0/8", // localhost
                "::1",       // localhosts
                "73.4.97.83" // comcast
                //"127.0.0.1" // localhost
            };
            var userIP = IPNetwork.Parse(ip);

            foreach (string r in ranges)
            {
                var range = IPNetwork.Parse(r);
                if (IPNetwork.Contains(range, userIP))
                {
                    return(true);
                }
            }
            return(false);
        }
コード例 #9
0
        /// <summary>
        /// Gets all unique <c>pairs</c> of hosts with monitoring flag set and which share the same subnet.<br/>
        /// Subnets with less than or more than two hosts will be discarded.
        /// </summary>
        /// <param name="hamnetDbAccess">The handle to access the database.</param>
        /// <param name="subnet">The subnet to return data for.</param>
        /// <returns>The dictionary mapping a subnet to its unique monitored host pair.</returns>
        public static IReadOnlyDictionary <IHamnetDbSubnet, IHamnetDbHosts> UniqueMonitoredHostPairsInSubnet(this IHamnetDbAccess hamnetDbAccess, IPNetwork subnet)
        {
            if (hamnetDbAccess == null)
            {
                throw new ArgumentNullException(nameof(hamnetDbAccess), "hamnetDbAccess to work with is null");
            }

            if (subnet == null)
            {
                throw new ArgumentNullException(nameof(subnet), "subnet search monitored hosts for is null");
            }

            var directSupportHamnetAccess = hamnetDbAccess as IDirectSupportOfHamnetDbAccessExtensions;

            if (directSupportHamnetAccess != null)
            {
                return(directSupportHamnetAccess.UniqueMonitoredHostPairsInSubnet(subnet));
            }

            var hosts      = hamnetDbAccess.QueryMonitoredHosts();
            var allSubnets = hamnetDbAccess.QuerySubnets();

            // filter out parents for which we have nested subnets
            var subnets = allSubnets.Where(s => !allSubnets.Any(a => !object.ReferenceEquals(s.Subnet, a.Subnet) && s.Subnet.Contains(a.Subnet)));

            var association = subnets.AssociateHosts(hosts);

            var uniquePairs = association
                              .Where(a => subnet.Contains(a.Key.Subnet) || subnet.Equals(a.Key.Subnet))
                              .Where(a => a.Value.Count == 2)
                              .ToDictionary(k => k.Key, v => v.Value);

            return(uniquePairs);
        }
コード例 #10
0
    public static bool IsIpInRange(string ip, string range)
    {
        IPNetwork IpNetwork  = IPNetwork.Parse(range);
        IPAddress incomingIp = IPAddress.Parse(ip);

        return(IPNetwork.Contains(IpNetwork, incomingIp));
    }
コード例 #11
0
        public bool IsInSubnet(Subnet source, Subnet toTest)
        {
            IPNetwork sourceSubnet = IPNetwork.Parse(source.IPAddress, source.Cidr);
            IPNetwork testSubnet   = IPNetwork.Parse(toTest.IPAddress, toTest.Cidr);

            return(sourceSubnet.Contains(testSubnet));
        }
コード例 #12
0
        private void AddListenIpToList()
        {
            string hostName    = Dns.GetHostName();
            var    addressList = Dns.GetHostAddresses(hostName);

            IPNetwork localnet192 = IPNetwork.Parse("192.168.0.0/16");
            IPNetwork localnet172 = IPNetwork.Parse("172.16.0.0/12");
            IPNetwork localnet169 = IPNetwork.Parse("169.254.0.0/16");
            IPNetwork localnet10  = IPNetwork.Parse("10.0.0.0/8");


            foreach (IPAddress ip in addressList.Distinct().ToList())
            {
                if (ip.IsIPv6LinkLocal || ip.IsIPv6Multicast || ip.IsIPv6SiteLocal || ip.IsIPv6Teredo)
                {
                    continue;
                }
                if (localnet192.Contains(ip) || localnet172.Contains(ip) || localnet169.Contains(ip) || localnet10.Contains(ip))
                {
                    continue;
                }
                if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    listListenIP.Items.Add(ip);
                }
                if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
                {
                    listListenIP.Items.Add(ip);
                }
            }
        }
コード例 #13
0
 private static void ContainNetwork(ProgramContext ac)
 {
     foreach (IPNetwork ipnetwork in ac.Networks)
     {
         bool contain = IPNetwork.Contains(ac.ContainNetwork, ipnetwork);
         Console.WriteLine("{0} contains {1} : {2}", ac.ContainNetwork, ipnetwork, contain);
     }
 }
コード例 #14
0
        private async Task StartIpBlur(IPRange ipRange)
        {
            bool validIp = IPAddress.TryParse(ipRange.StartIpHolder, out IPAddress ipAddress);

            if (!validIp)
            {
                ipRange.IpInvalidMessage = "Network IP address is not valid.";
                ipRange.HolderIpInvalid  = !validIp;
                return;
            }

            // RFC1918
            IPNetwork network1 = IPNetwork.Parse("10.0.0.0/8");
            IPNetwork network2 = IPNetwork.Parse("172.16.0.0/12");
            IPNetwork network3 = IPNetwork.Parse("192.168.0.0/16");

            if (!network1.Contains(ipAddress) && !network2.Contains(ipAddress) && !network3.Contains(ipAddress))
            {
                ipRange.IpInvalidMessage = $"Network IP address is not recommended. " +
                                           $"<a href=\"https://docs.microsoft.com/en-us/azure/virtual-network/virtual-networks-faq#what-address-ranges-can-i-use-in-my-vnets\" target=\"_blank\">More info</a>";
                ipRange.HolderIpInvalid = true;
                return;
            }

            ipRange.HolderIpInvalid  = false;
            ipRange.IpInvalidMessage = string.Empty;
            var subnets = _vnet.Subnets.Where(s => s.IPRangeId == ipRange.Id).ToList();

            if (subnets.Count > 0 && ipRange.StartIpHolder != ipRange.StartIP)
            {
                // Too complex to sort out new addresses for all subnets. So reset them.
                var content       = "Chaning network IP will reset all its subnets!";
                var title         = "Warning";
                var confirmResult = await _confirmService.Show(content, title, ConfirmButtons.OKCancel, ConfirmIcon.Warning,
                                                               new ConfirmButtonOptions()
                {
                    Button1Props = new ButtonProps()
                    {
                        Type   = "primary",
                        Danger = true
                    }
                });

                if (confirmResult == ConfirmResult.OK)
                {
                    _vnet.SetVnetStartIp(ipRange.Id, ipRange.StartIpHolder);
                    _vnet.ResetSubnets(ipRange.Id);
                }
            }
            else
            {
                _vnet.SetVnetStartIp(ipRange.Id, ipRange.StartIpHolder);
            }

            ipRange.StartIpHolder = ipRange.StartIP;
        }
コード例 #15
0
        public static bool IsAllowed(HttpContext context)
        {
            var ip = GetIpAddress(context);

            var userIsOnEsportsNetwork = IPNetwork.Contains(EsportsNetwork, IPAddress.Parse(ip));
            var userIsOnEduroamNetwork = IPNetwork.Contains(EduroamNetwork, IPAddress.Parse(ip));
            var userIsLocalhost        = IPNetwork.Contains(LocalhostNetwork, IPAddress.Parse(ip));
            var userIsLocalhostIPv6    = IPNetwork.Contains(LocalhostNetworkIPv6, IPAddress.Parse(ip));

            return(userIsOnEsportsNetwork || userIsOnEduroamNetwork || userIsLocalhost || userIsLocalhostIPv6);
        }
コード例 #16
0
    /// <summary>
    /// 2 개의 IP 를 비교하여 ipAddr2 가 ipAddr1 에 속하는지 여부를 반환합니다.
    /// </summary>
    /// <param name="ipAddr1">기준이 되는 Ip Addr</param>
    /// <param name="ipAddr2">ipAddr1 에 종속되는 ip 인지 확인할 Ip Addr</param>
    /// <returns>ture : ipAddr2 가 ipAddr1 에 종속 / false : ipAddr2 가 ipAddr1 에 종속되지 않음</returns>
    public static bool ValidationIpAddresInGroup(string ipAddr1, string ipAddr2)
    {
        bool returnResult = false;

        IPNetwork ipnetwork = IPNetwork.Parse(ipAddr1 + "/24");
        IPAddress ipaddress = IPAddress.Parse(ipAddr2);

        returnResult = IPNetwork.Contains(ipnetwork, ipaddress);

        return(returnResult);
    }
コード例 #17
0
        /// <summary>
        /// Localiza la ip
        /// </summary>
        /// <param name="address">Direccón</param>
        public GeoLocateResult LocateIp(IPAddress address)
        {
            foreach (geoIp g in _Locates)
            {
                if (IPNetwork.Contains(g.Network, address))
                {
                    return(g.Result);
                }
            }

            return(GeoLocateResult.Empty);
        }
コード例 #18
0
        public static bool ValidaRangoIPV4(string ipDir, string dirRed, string cidr)
        {
            string    rango      = dirRed + cidr;
            IPNetwork ipnetwork  = IPNetwork.Parse(rango);
            IPAddress ipaddress  = IPAddress.Parse(ipDir);
            IPAddress ipaddress2 = IPAddress.Parse("192.168.0.200");

#pragma warning disable CS0618 // El tipo o el miembro están obsoletos
            bool contains = IPNetwork.Contains(ipnetwork, ipaddress);
#pragma warning restore CS0618 // El tipo o el miembro están obsoletos

            return(contains);
        }
コード例 #19
0
        public static bool ValidaRangoIPV6(string ipDir, string dirRed, string cidr)
        {
            string    rango      = dirRed + cidr;
            IPNetwork ipnetwork  = IPNetwork.Parse(rango);
            IPAddress ipaddress  = IPAddress.Parse(ipDir);
            IPAddress ipaddress2 = IPAddress.Parse("fe80::202:b3ff:fe1e:1");

#pragma warning disable CS0618 // El tipo o el miembro están obsoletos Ignoramos la advertencia del compilador
            bool contains = IPNetwork.Contains(ipnetwork, ipaddress);
#pragma warning restore CS0618 // El tipo o el miembro están obsoletos

            return(contains);
        }
コード例 #20
0
        public void ParseTest()
        {
            //http://www.subnet-calculator.com/cidr.php
            //IPNetwork mynetwork = new IPNetwork();
            IPNetwork ipnetwork = IPNetwork.Parse("198.169.76.64/26");
            IPAddress ipaddress = IPAddress.Parse("198.169.76.75");
            //198.238.108.200

            bool result   = IPNetwork.Contains(ipnetwork, ipaddress);
            bool expected = true;

            Assert.AreEqual(expected, result, "contains");
        }
コード例 #21
0
        public static bool IsCloudFlareIP(string ip)
        {
            foreach (string block in CloudFlareIPRanges)
            {
                IPNetwork network = IPNetwork.Parse(block);

                if (IPNetwork.Contains(network, IPAddress.Parse(ip)))
                {
                    return(true);
                }
            }

            return(false);
        }
コード例 #22
0
        public static bool IsBlocked(string ip)
        {
            IPAddress ipAddress;

            if (ip != null && ip == "::1")
            {
                ip = "127.0.0.1";
            }
            if (IPAddress.TryParse(ip, out ipAddress))
            {
                return(BlockedIpList.Any(n => IPNetwork.Contains(n, ipAddress)));
            }
            return(true);
        }
コード例 #23
0
ファイル: DistinguishIpBlock.cs プロジェクト: step4u/MiniCRM
        public static bool IsIpNat(string ip)
        {
            IPAddress incomingIp = IPAddress.Parse(ip);

            foreach (var subnet in IpBlocks)
            {
                IPNetwork network = IPNetwork.Parse(subnet);

                if (IPNetwork.Contains(network, incomingIp))
                {
                    return(true);
                }
            }
            return(false);
        }
コード例 #24
0
        public static bool IsUserIpWhiteListed(string userIp, string acl)
        {
            var aclList = acl.Split(',').ToList();

            //try for a exact IP match
            if (aclList.Contains(userIp) || userIp == "127.0.0.1")
            {
                return(true);
            }

            //try for a network match by CIDR notation; i.e. 10.0.0.0/8
            var networkList = aclList.Where(x => x.Contains('/'));

            return(networkList.Any(x => IPNetwork.Contains(IPNetwork.Parse(x), IPAddress.Parse(userIp))));
        }
コード例 #25
0
 private static string DetermineIPv4AddressType(IPAddress address)
 {
     if (MulticastNetwork.Contains(address))
     {
         return("multicast");
     }
     else if (PrivateUseNetworks.Any(network => network.Contains(address)))
     {
         return("private");
     }
     else
     {
         return("public");
     }
 }
コード例 #26
0
        public string GetRegionNameByIpOrUrl(string ipOrUrl, string ipFilePath = null)
        {
            if (string.IsNullOrEmpty(ipOrUrl))
            {
                return("Must specify a valid ipAddress or url");
            }

            if (string.IsNullOrEmpty(ipFilePath))
            {
                ipFilePath = HostingEnvironment.MapPath("~/App_Data/");
            }

            if (!(ipOrUrl.StartsWith("http://") || ipOrUrl.StartsWith("https://")))
            {
                ipOrUrl = "http://" + ipOrUrl;
            }
            Uri tmp = new Uri(ipOrUrl);

            ipOrUrl = tmp.Host;


            var sw = new Stopwatch();

            sw.Start();
            try
            {
                var ips     = Dns.GetHostAddresses(ipOrUrl);
                var ipAddr  = ips[0];
                var subnets = SubnetBuilder.GetSubnetDictionary(ipFilePath);
                foreach (IPNetwork net in subnets.Keys)
                {
                    if (IPNetwork.Contains(net, ipAddr))
                    {
                        var regionAlias = subnets[net];
                        sw.Stop();
                        string region = AzureSpeedData.RegionNames[regionAlias];
                        logger.Info("IpOrUrl = {0}, region = {1}, time = {2}", ipOrUrl, region, sw.ElapsedMilliseconds);
                        return(region);
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                return("Invalid Address!");
            }
            return("Region not found");
        }
コード例 #27
0
    public static bool IpIsWithinCloudfareIPRange(string ip)
    {
        IPAddress incomingIp = IPAddress.Parse(ip);

        var cache = new CloudfareIPCache();
        var range = (List <IPNetwork>)cache.Get();

        foreach (var network in range)
        {
            if (IPNetwork.Contains(network, incomingIp))
            {
                return(true);
            }
        }
        return(false);
    }
コード例 #28
0
ファイル: MulticastListener.cs プロジェクト: asimshah/Core
        private static IPAddress GetLocalIpAddress(IPNetwork localNetwork)
        {
            var host = Dns.GetHostEntry(Dns.GetHostName());

            foreach (var ip in host.AddressList)
            {
                if (localNetwork.Contains(ip))
                {
                    return(ip);
                }
                //if (IPNetwork.Contains(localNetwork, ip))
                //{
                //    return ip;
                //}
            }
            throw new Exception("Local IP Address Not Found!");
        }
コード例 #29
0
        /// <summary>
        /// Checks whether two ip ranges (networks) overlap.
        /// </summary>
        public static bool CIDROverlaps(string cidr1, string cidr2)
        {
            IPNetwork net1 = IPNetwork.Parse(cidr1);
            IPNetwork net2 = IPNetwork.Parse(cidr2);

            bool net1Contains = IPNetwork.Contains(net1, net2.Network) || IPNetwork.Contains(net1, net2.Broadcast);
            bool net2Contains = IPNetwork.Contains(net2, net1.Network) || IPNetwork.Contains(net2, net1.Broadcast);


            if (net1Contains || net2Contains)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
コード例 #30
0
        public Guid GetLocationIdByIp(string ip)
        {
            IPAddress ipAddress;

            if (!IPAddress.TryParse(ip, out ipAddress))
            {
                return(Guid.Empty);
            }

            var networks = _locationRepository.GetAllLocationNetworks().Where(n => n.Network.AddressFamily == ipAddress.AddressFamily);

            Guid match = networks
                         .Where(n => IPNetwork.Contains(n.Network, ipAddress))
                         .OrderByDescending(n => n.Cidr)
                         .Select(n => n.Id)
                         .FirstOrDefault();

            return(match);
        }